using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Runtime;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Text;
using System.Threading;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("System.Runtime")]
[assembly: AssemblyDescription("System.Runtime")]
[assembly: AssemblyDefaultAlias("System.Runtime")]
[assembly: AssemblyCompany("Mono development team")]
[assembly: AssemblyProduct("Mono Common Language Infrastructure")]
[assembly: AssemblyCopyright("(c) Various Mono authors")]
[assembly: AssemblyInformationalVersion("4.0.0.0")]
[assembly: AssemblyFileVersion("4.0.0.0")]
[assembly: AssemblyVersion("4.1.0.0")]
[assembly: TypeForwardedTo(typeof(Action))]
[assembly: TypeForwardedTo(typeof(Action<>))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, >))]
[assembly: TypeForwardedTo(typeof(Action<, , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Action<, , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Activator))]
[assembly: TypeForwardedTo(typeof(ArgumentException))]
[assembly: TypeForwardedTo(typeof(ArgumentNullException))]
[assembly: TypeForwardedTo(typeof(ArgumentOutOfRangeException))]
[assembly: TypeForwardedTo(typeof(ArithmeticException))]
[assembly: TypeForwardedTo(typeof(Array))]
[assembly: TypeForwardedTo(typeof(ArraySegment<>))]
[assembly: TypeForwardedTo(typeof(ArrayTypeMismatchException))]
[assembly: TypeForwardedTo(typeof(AsyncCallback))]
[assembly: TypeForwardedTo(typeof(Attribute))]
[assembly: TypeForwardedTo(typeof(AttributeTargets))]
[assembly: TypeForwardedTo(typeof(AttributeUsageAttribute))]
[assembly: TypeForwardedTo(typeof(BadImageFormatException))]
[assembly: TypeForwardedTo(typeof(bool))]
[assembly: TypeForwardedTo(typeof(Buffer))]
[assembly: TypeForwardedTo(typeof(byte))]
[assembly: TypeForwardedTo(typeof(char))]
[assembly: TypeForwardedTo(typeof(CLSCompliantAttribute))]
[assembly: TypeForwardedTo(typeof(DictionaryEntry))]
[assembly: TypeForwardedTo(typeof(ICollection<>))]
[assembly: TypeForwardedTo(typeof(IComparer<>))]
[assembly: TypeForwardedTo(typeof(IDictionary<, >))]
[assembly: TypeForwardedTo(typeof(IEnumerable<>))]
[assembly: TypeForwardedTo(typeof(IEnumerator<>))]
[assembly: TypeForwardedTo(typeof(IEqualityComparer<>))]
[assembly: TypeForwardedTo(typeof(IList<>))]
[assembly: TypeForwardedTo(typeof(IReadOnlyCollection<>))]
[assembly: TypeForwardedTo(typeof(IReadOnlyDictionary<, >))]
[assembly: TypeForwardedTo(typeof(IReadOnlyList<>))]
[assembly: TypeForwardedTo(typeof(ISet<>))]
[assembly: TypeForwardedTo(typeof(KeyNotFoundException))]
[assembly: TypeForwardedTo(typeof(KeyValuePair<, >))]
[assembly: TypeForwardedTo(typeof(ICollection))]
[assembly: TypeForwardedTo(typeof(IComparer))]
[assembly: TypeForwardedTo(typeof(IDictionary))]
[assembly: TypeForwardedTo(typeof(IDictionaryEnumerator))]
[assembly: TypeForwardedTo(typeof(IEnumerable))]
[assembly: TypeForwardedTo(typeof(IEnumerator))]
[assembly: TypeForwardedTo(typeof(IEqualityComparer))]
[assembly: TypeForwardedTo(typeof(IList))]
[assembly: TypeForwardedTo(typeof(IStructuralComparable))]
[assembly: TypeForwardedTo(typeof(IStructuralEquatable))]
[assembly: TypeForwardedTo(typeof(Collection<>))]
[assembly: TypeForwardedTo(typeof(ReadOnlyCollection<>))]
[assembly: TypeForwardedTo(typeof(Comparison<>))]
[assembly: TypeForwardedTo(typeof(DefaultValueAttribute))]
[assembly: TypeForwardedTo(typeof(EditorBrowsableAttribute))]
[assembly: TypeForwardedTo(typeof(EditorBrowsableState))]
[assembly: TypeForwardedTo(typeof(DateTime))]
[assembly: TypeForwardedTo(typeof(DateTimeKind))]
[assembly: TypeForwardedTo(typeof(DateTimeOffset))]
[assembly: TypeForwardedTo(typeof(DayOfWeek))]
[assembly: TypeForwardedTo(typeof(decimal))]
[assembly: TypeForwardedTo(typeof(Delegate))]
[assembly: TypeForwardedTo(typeof(ConditionalAttribute))]
[assembly: TypeForwardedTo(typeof(DebuggableAttribute))]
[assembly: TypeForwardedTo(typeof(DivideByZeroException))]
[assembly: TypeForwardedTo(typeof(double))]
[assembly: TypeForwardedTo(typeof(Enum))]
[assembly: TypeForwardedTo(typeof(EventArgs))]
[assembly: TypeForwardedTo(typeof(EventHandler))]
[assembly: TypeForwardedTo(typeof(EventHandler<>))]
[assembly: TypeForwardedTo(typeof(Exception))]
[assembly: TypeForwardedTo(typeof(FieldAccessException))]
[assembly: TypeForwardedTo(typeof(FlagsAttribute))]
[assembly: TypeForwardedTo(typeof(FormatException))]
[assembly: TypeForwardedTo(typeof(FormattableString))]
[assembly: TypeForwardedTo(typeof(Func<>))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , , , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, >))]
[assembly: TypeForwardedTo(typeof(Func<, , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Func<, , , , , , , , >))]
[assembly: TypeForwardedTo(typeof(GC))]
[assembly: TypeForwardedTo(typeof(GCCollectionMode))]
[assembly: TypeForwardedTo(typeof(DateTimeStyles))]
[assembly: TypeForwardedTo(typeof(NumberStyles))]
[assembly: TypeForwardedTo(typeof(TimeSpanStyles))]
[assembly: TypeForwardedTo(typeof(Guid))]
[assembly: TypeForwardedTo(typeof(IAsyncResult))]
[assembly: TypeForwardedTo(typeof(IComparable))]
[assembly: TypeForwardedTo(typeof(IComparable<>))]
[assembly: TypeForwardedTo(typeof(IConvertible))]
[assembly: TypeForwardedTo(typeof(ICustomFormatter))]
[assembly: TypeForwardedTo(typeof(IDisposable))]
[assembly: TypeForwardedTo(typeof(IEquatable<>))]
[assembly: TypeForwardedTo(typeof(IFormatProvider))]
[assembly: TypeForwardedTo(typeof(IFormattable))]
[assembly: TypeForwardedTo(typeof(IndexOutOfRangeException))]
[assembly: TypeForwardedTo(typeof(InsufficientExecutionStackException))]
[assembly: TypeForwardedTo(typeof(short))]
[assembly: TypeForwardedTo(typeof(int))]
[assembly: TypeForwardedTo(typeof(long))]
[assembly: TypeForwardedTo(typeof(IntPtr))]
[assembly: TypeForwardedTo(typeof(InvalidCastException))]
[assembly: TypeForwardedTo(typeof(InvalidOperationException))]
[assembly: TypeForwardedTo(typeof(InvalidProgramException))]
[assembly: TypeForwardedTo(typeof(InvalidTimeZoneException))]
[assembly: TypeForwardedTo(typeof(DirectoryNotFoundException))]
[assembly: TypeForwardedTo(typeof(FileLoadException))]
[assembly: TypeForwardedTo(typeof(FileNotFoundException))]
[assembly: TypeForwardedTo(typeof(IOException))]
[assembly: TypeForwardedTo(typeof(PathTooLongException))]
[assembly: TypeForwardedTo(typeof(IObservable<>))]
[assembly: TypeForwardedTo(typeof(IObserver<>))]
[assembly: TypeForwardedTo(typeof(IProgress<>))]
[assembly: TypeForwardedTo(typeof(Lazy<>))]
[assembly: TypeForwardedTo(typeof(Lazy<, >))]
[assembly: TypeForwardedTo(typeof(MemberAccessException))]
[assembly: TypeForwardedTo(typeof(MethodAccessException))]
[assembly: TypeForwardedTo(typeof(MissingFieldException))]
[assembly: TypeForwardedTo(typeof(MissingMemberException))]
[assembly: TypeForwardedTo(typeof(MissingMethodException))]
[assembly: TypeForwardedTo(typeof(MTAThreadAttribute))]
[assembly: TypeForwardedTo(typeof(MulticastDelegate))]
[assembly: TypeForwardedTo(typeof(NotImplementedException))]
[assembly: TypeForwardedTo(typeof(NotSupportedException))]
[assembly: TypeForwardedTo(typeof(Nullable))]
[assembly: TypeForwardedTo(typeof(Nullable<>))]
[assembly: TypeForwardedTo(typeof(NullReferenceException))]
[assembly: TypeForwardedTo(typeof(object))]
[assembly: TypeForwardedTo(typeof(ObjectDisposedException))]
[assembly: TypeForwardedTo(typeof(ObsoleteAttribute))]
[assembly: TypeForwardedTo(typeof(OutOfMemoryException))]
[assembly: TypeForwardedTo(typeof(OverflowException))]
[assembly: TypeForwardedTo(typeof(ParamArrayAttribute))]
[assembly: TypeForwardedTo(typeof(PlatformNotSupportedException))]
[assembly: TypeForwardedTo(typeof(Predicate<>))]
[assembly: TypeForwardedTo(typeof(RankException))]
[assembly: TypeForwardedTo(typeof(AssemblyCompanyAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyConfigurationAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyCopyrightAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyCultureAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyDefaultAliasAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyDelaySignAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyDescriptionAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyFileVersionAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyFlagsAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyInformationalVersionAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyKeyFileAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyKeyNameAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyMetadataAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyNameFlags))]
[assembly: TypeForwardedTo(typeof(AssemblyProductAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblySignatureKeyAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyTitleAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyTrademarkAttribute))]
[assembly: TypeForwardedTo(typeof(AssemblyVersionAttribute))]
[assembly: TypeForwardedTo(typeof(DefaultMemberAttribute))]
[assembly: TypeForwardedTo(typeof(ProcessorArchitecture))]
[assembly: TypeForwardedTo(typeof(AccessedThroughPropertyAttribute))]
[assembly: TypeForwardedTo(typeof(AsyncStateMachineAttribute))]
[assembly: TypeForwardedTo(typeof(CallerFilePathAttribute))]
[assembly: TypeForwardedTo(typeof(CallerLineNumberAttribute))]
[assembly: TypeForwardedTo(typeof(CallerMemberNameAttribute))]
[assembly: TypeForwardedTo(typeof(CompilationRelaxationsAttribute))]
[assembly: TypeForwardedTo(typeof(CompilerGeneratedAttribute))]
[assembly: TypeForwardedTo(typeof(ConditionalWeakTable<, >))]
[assembly: TypeForwardedTo(typeof(CustomConstantAttribute))]
[assembly: TypeForwardedTo(typeof(DateTimeConstantAttribute))]
[assembly: TypeForwardedTo(typeof(DecimalConstantAttribute))]
[assembly: TypeForwardedTo(typeof(DisablePrivateReflectionAttribute))]
[assembly: TypeForwardedTo(typeof(ExtensionAttribute))]
[assembly: TypeForwardedTo(typeof(FixedBufferAttribute))]
[assembly: TypeForwardedTo(typeof(FormattableStringFactory))]
[assembly: TypeForwardedTo(typeof(IndexerNameAttribute))]
[assembly: TypeForwardedTo(typeof(InternalsVisibleToAttribute))]
[assembly: TypeForwardedTo(typeof(IsConst))]
[assembly: TypeForwardedTo(typeof(IStrongBox))]
[assembly: TypeForwardedTo(typeof(IsVolatile))]
[assembly: TypeForwardedTo(typeof(IteratorStateMachineAttribute))]
[assembly: TypeForwardedTo(typeof(MethodImplAttribute))]
[assembly: TypeForwardedTo(typeof(MethodImplOptions))]
[assembly: TypeForwardedTo(typeof(ReferenceAssemblyAttribute))]
[assembly: TypeForwardedTo(typeof(RuntimeCompatibilityAttribute))]
[assembly: TypeForwardedTo(typeof(RuntimeHelpers))]
[assembly: TypeForwardedTo(typeof(StateMachineAttribute))]
[assembly: TypeForwardedTo(typeof(StrongBox<>))]
[assembly: TypeForwardedTo(typeof(TypeForwardedFromAttribute))]
[assembly: TypeForwardedTo(typeof(TypeForwardedToAttribute))]
[assembly: TypeForwardedTo(typeof(UnsafeValueTypeAttribute))]
[assembly: TypeForwardedTo(typeof(ExceptionDispatchInfo))]
[assembly: TypeForwardedTo(typeof(GCLargeObjectHeapCompactionMode))]
[assembly: TypeForwardedTo(typeof(GCLatencyMode))]
[assembly: TypeForwardedTo(typeof(GCSettings))]
[assembly: TypeForwardedTo(typeof(CharSet))]
[assembly: TypeForwardedTo(typeof(ComVisibleAttribute))]
[assembly: TypeForwardedTo(typeof(FieldOffsetAttribute))]
[assembly: TypeForwardedTo(typeof(GCHandle))]
[assembly: TypeForwardedTo(typeof(GCHandleType))]
[assembly: TypeForwardedTo(typeof(LayoutKind))]
[assembly: TypeForwardedTo(typeof(OutAttribute))]
[assembly: TypeForwardedTo(typeof(StructLayoutAttribute))]
[assembly: TypeForwardedTo(typeof(TargetFrameworkAttribute))]
[assembly: TypeForwardedTo(typeof(RuntimeFieldHandle))]
[assembly: TypeForwardedTo(typeof(RuntimeMethodHandle))]
[assembly: TypeForwardedTo(typeof(RuntimeTypeHandle))]
[assembly: TypeForwardedTo(typeof(sbyte))]
[assembly: TypeForwardedTo(typeof(AllowPartiallyTrustedCallersAttribute))]
[assembly: TypeForwardedTo(typeof(SecurityCriticalAttribute))]
[assembly: TypeForwardedTo(typeof(SecurityException))]
[assembly: TypeForwardedTo(typeof(SecuritySafeCriticalAttribute))]
[assembly: TypeForwardedTo(typeof(SecurityTransparentAttribute))]
[assembly: TypeForwardedTo(typeof(VerificationException))]
[assembly: TypeForwardedTo(typeof(float))]
[assembly: TypeForwardedTo(typeof(STAThreadAttribute))]
[assembly: TypeForwardedTo(typeof(string))]
[assembly: TypeForwardedTo(typeof(StringComparison))]
[assembly: TypeForwardedTo(typeof(StringSplitOptions))]
[assembly: TypeForwardedTo(typeof(StringBuilder))]
[assembly: TypeForwardedTo(typeof(LazyThreadSafetyMode))]
[assembly: TypeForwardedTo(typeof(Timeout))]
[assembly: TypeForwardedTo(typeof(WaitHandle))]
[assembly: TypeForwardedTo(typeof(ThreadStaticAttribute))]
[assembly: TypeForwardedTo(typeof(TimeoutException))]
[assembly: TypeForwardedTo(typeof(TimeSpan))]
[assembly: TypeForwardedTo(typeof(TimeZoneInfo))]
[assembly: TypeForwardedTo(typeof(Tuple))]
[assembly: TypeForwardedTo(typeof(Tuple<>))]
[assembly: TypeForwardedTo(typeof(Tuple<, >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , , , >))]
[assembly: TypeForwardedTo(typeof(Tuple<, , , , , , , >))]
[assembly: TypeForwardedTo(typeof(Type))]
[assembly: TypeForwardedTo(typeof(TypeAccessException))]
[assembly: TypeForwardedTo(typeof(TypeCode))]
[assembly: TypeForwardedTo(typeof(TypeInitializationException))]
[assembly: TypeForwardedTo(typeof(TypeLoadException))]
[assembly: TypeForwardedTo(typeof(ushort))]
[assembly: TypeForwardedTo(typeof(uint))]
[assembly: TypeForwardedTo(typeof(ulong))]
[assembly: TypeForwardedTo(typeof(UIntPtr))]
[assembly: TypeForwardedTo(typeof(UnauthorizedAccessException))]
[assembly: TypeForwardedTo(typeof(Uri))]
[assembly: TypeForwardedTo(typeof(UriComponents))]
[assembly: TypeForwardedTo(typeof(UriFormat))]
[assembly: TypeForwardedTo(typeof(UriFormatException))]
[assembly: TypeForwardedTo(typeof(UriHostNameType))]
[assembly: TypeForwardedTo(typeof(UriKind))]
[assembly: TypeForwardedTo(typeof(ValueType))]
[assembly: TypeForwardedTo(typeof(Version))]
[assembly: TypeForwardedTo(typeof(void))]
[assembly: TypeForwardedTo(typeof(WeakReference))]
[assembly: TypeForwardedTo(typeof(WeakReference<>))]

#define DEBUG
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AOT;
using Microsoft.CodeAnalysis;
using Unity.Burst.LowLevel;
using Unity.Collections.LowLevel.Unsafe;
using Unity.Jobs.LowLevel.Unsafe;
using UnityEngine;
using UnityEngine.Scripting;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: InternalsVisibleTo("Unity.Burst.CodeGen")]
[assembly: InternalsVisibleTo("Unity.Burst.Editor")]
[assembly: InternalsVisibleTo("Unity.Burst.Tests.UnitTests")]
[assembly: InternalsVisibleTo("Unity.Burst.Editor.Tests")]
[assembly: InternalsVisibleTo("Unity.Burst.Benchmarks")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
}
namespace Unity.Burst
{
	public enum OptimizeFor
	{
		Default,
		Performance,
		Size,
		FastCompilation,
		Balanced
	}
	public enum FloatMode
	{
		Default,
		Strict,
		Deterministic,
		Fast
	}
	public enum FloatPrecision
	{
		Standard,
		High,
		Medium,
		Low
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method)]
	public class BurstCompileAttribute : Attribute
	{
		internal bool? _compileSynchronously;

		internal bool? _debug;

		internal bool? _disableSafetyChecks;

		internal bool? _disableDirectCall;

		public FloatMode FloatMode { get; set; }

		public FloatPrecision FloatPrecision { get; set; }

		public bool CompileSynchronously
		{
			get
			{
				return _compileSynchronously.HasValue && _compileSynchronously.Value;
			}
			set
			{
				_compileSynchronously = value;
			}
		}

		public bool Debug
		{
			get
			{
				return _debug.HasValue && _debug.Value;
			}
			set
			{
				_debug = value;
			}
		}

		public bool DisableSafetyChecks
		{
			get
			{
				return _disableSafetyChecks.HasValue && _disableSafetyChecks.Value;
			}
			set
			{
				_disableSafetyChecks = value;
			}
		}

		public bool DisableDirectCall
		{
			get
			{
				return _disableDirectCall.HasValue && _disableDirectCall.Value;
			}
			set
			{
				_disableDirectCall = value;
			}
		}

		public OptimizeFor OptimizeFor { get; set; }

		internal string[] Options { get; set; }

		public BurstCompileAttribute()
		{
		}

		public BurstCompileAttribute(FloatPrecision floatPrecision, FloatMode floatMode)
		{
			FloatMode = floatMode;
			FloatPrecision = floatPrecision;
		}

		internal BurstCompileAttribute(string[] options)
		{
			Options = options;
		}
	}
	public static class BurstCompiler
	{
		private class CommandBuilder
		{
			private StringBuilder _builder;

			private bool _hasArgs;

			public CommandBuilder()
			{
				_builder = new StringBuilder();
				_hasArgs = false;
			}

			public CommandBuilder Begin(string cmd)
			{
				_builder.Clear();
				_hasArgs = false;
				_builder.Append(cmd);
				return this;
			}

			public CommandBuilder With(string arg)
			{
				if (!_hasArgs)
				{
					_builder.Append(' ');
				}
				_hasArgs = true;
				_builder.Append(arg);
				return this;
			}

			public CommandBuilder With(IntPtr arg)
			{
				if (!_hasArgs)
				{
					_builder.Append(' ');
				}
				_hasArgs = true;
				_builder.AppendFormat("0x{0:X16}", arg.ToInt64());
				return this;
			}

			public CommandBuilder And(char sep = '|')
			{
				_builder.Append(sep);
				return this;
			}

			public string SendToCompiler()
			{
				return SendRawCommandToCompiler(_builder.ToString());
			}
		}

		[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
		internal class StaticTypeReinitAttribute : Attribute
		{
			public readonly Type reinitType;

			public StaticTypeReinitAttribute(Type toReinit)
			{
				reinitType = toReinit;
			}
		}

		[BurstCompile]
		internal static class BurstCompilerHelper
		{
			[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
			private delegate bool IsBurstEnabledDelegate();

			private static readonly IsBurstEnabledDelegate IsBurstEnabledImpl = IsBurstEnabled;

			public static readonly bool IsBurstGenerated = IsCompiledByBurst(IsBurstEnabledImpl);

			[BurstCompile]
			[MonoPInvokeCallback(typeof(IsBurstEnabledDelegate))]
			private static bool IsBurstEnabled()
			{
				bool value = true;
				DiscardedMethod(ref value);
				return value;
			}

			[BurstDiscard]
			private static void DiscardedMethod(ref bool value)
			{
				value = false;
			}

			private unsafe static bool IsCompiledByBurst(Delegate del)
			{
				int num = BurstCompilerService.CompileAsyncDelegateMethod((object)del, string.Empty);
				return BurstCompilerService.GetAsyncCompiledAsyncDelegateMethod(num) != null;
			}
		}

		private class FakeDelegate
		{
			[Preserve]
			public MethodInfo Method { get; }

			public FakeDelegate(MethodInfo method)
			{
				Method = method;
			}
		}

		[ThreadStatic]
		private static CommandBuilder _cmdBuilder;

		internal static bool _IsEnabled;

		public static readonly BurstCompilerOptions Options = new BurstCompilerOptions(isGlobal: true);

		internal static Action OnCompileILPPMethod2;

		private static readonly MethodInfo DummyMethodInfo = typeof(BurstCompiler).GetMethod("DummyMethod", BindingFlags.Static | BindingFlags.NonPublic);

		public static bool IsEnabled => _IsEnabled && BurstCompilerHelper.IsBurstGenerated;

		public static bool IsLoadAdditionalLibrarySupported()
		{
			return IsApiAvailable("LoadBurstLibrary");
		}

		private static CommandBuilder BeginCompilerCommand(string cmd)
		{
			if (_cmdBuilder == null)
			{
				_cmdBuilder = new CommandBuilder();
			}
			return _cmdBuilder.Begin(cmd);
		}

		public static void SetExecutionMode(BurstExecutionEnvironment mode)
		{
			BurstCompilerService.SetCurrentExecutionMode((uint)mode);
		}

		public static BurstExecutionEnvironment GetExecutionMode()
		{
			return (BurstExecutionEnvironment)BurstCompilerService.GetCurrentExecutionMode();
		}

		internal unsafe static T CompileDelegate<T>(T delegateMethod) where T : class
		{
			void* ptr = Compile(delegateMethod, isFunctionPointer: false);
			object delegateForFunctionPointer = Marshal.GetDelegateForFunctionPointer((IntPtr)ptr, delegateMethod.GetType());
			return (T)delegateForFunctionPointer;
		}

		[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
		private static void VerifyDelegateIsNotMulticast<T>(T delegateMethod) where T : class
		{
			Delegate @delegate = delegateMethod as Delegate;
			if (@delegate.GetInvocationList().Length > 1)
			{
				throw new InvalidOperationException($"Burst does not support multicast delegates, please use a regular delegate for `{delegateMethod}'");
			}
		}

		[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
		private static void VerifyDelegateHasCorrectUnmanagedFunctionPointerAttribute<T>(T delegateMethod) where T : class
		{
			UnmanagedFunctionPointerAttribute customAttribute = delegateMethod.GetType().GetCustomAttribute<UnmanagedFunctionPointerAttribute>();
			if (customAttribute == null || customAttribute.CallingConvention != CallingConvention.Cdecl)
			{
				Debug.LogWarning((object)("The delegate type " + delegateMethod.GetType().FullName + " should be decorated with [UnmanagedFunctionPointer(CallingConvention.Cdecl)] to ensure runtime interoperabilty between managed code and Burst-compiled code."));
			}
		}

		[Obsolete("This method will be removed in a future version of Burst")]
		public static IntPtr CompileILPPMethod(RuntimeMethodHandle burstMethodHandle, RuntimeMethodHandle managedMethodHandle, RuntimeTypeHandle delegateTypeHandle)
		{
			throw new NotImplementedException();
		}

		public unsafe static IntPtr CompileILPPMethod2(RuntimeMethodHandle burstMethodHandle)
		{
			if (burstMethodHandle.Value == IntPtr.Zero)
			{
				throw new ArgumentNullException("burstMethodHandle");
			}
			OnCompileILPPMethod2?.Invoke();
			MethodInfo methodInfo = (MethodInfo)MethodBase.GetMethodFromHandle(burstMethodHandle);
			return (IntPtr)Compile(new FakeDelegate(methodInfo), methodInfo, isFunctionPointer: true, isILPostProcessing: true);
		}

		[Obsolete("This method will be removed in a future version of Burst")]
		public unsafe static void* GetILPPMethodFunctionPointer(IntPtr ilppMethod)
		{
			throw new NotImplementedException();
		}

		public unsafe static void* GetILPPMethodFunctionPointer2(IntPtr ilppMethod, RuntimeMethodHandle managedMethodHandle, RuntimeTypeHandle delegateTypeHandle)
		{
			if (ilppMethod == IntPtr.Zero)
			{
				throw new ArgumentNullException("ilppMethod");
			}
			if (managedMethodHandle.Value == IntPtr.Zero)
			{
				throw new ArgumentNullException("managedMethodHandle");
			}
			if (delegateTypeHandle.Value == IntPtr.Zero)
			{
				throw new ArgumentNullException("delegateTypeHandle");
			}
			return ilppMethod.ToPointer();
		}

		[Obsolete("This method will be removed in a future version of Burst")]
		public unsafe static void* CompileUnsafeStaticMethod(RuntimeMethodHandle handle)
		{
			throw new NotImplementedException();
		}

		public unsafe static FunctionPointer<T> CompileFunctionPointer<T>(T delegateMethod) where T : class
		{
			void* value = Compile(delegateMethod, isFunctionPointer: true);
			return new FunctionPointer<T>(new IntPtr(value));
		}

		private unsafe static void* Compile(object delegateObj, bool isFunctionPointer)
		{
			if (!(delegateObj is Delegate))
			{
				throw new ArgumentException("object instance must be a System.Delegate", "delegateObj");
			}
			Delegate @delegate = (Delegate)delegateObj;
			return Compile(@delegate, @delegate.Method, isFunctionPointer, isILPostProcessing: false);
		}

		private unsafe static void* Compile(object delegateObj, MethodInfo methodInfo, bool isFunctionPointer, bool isILPostProcessing)
		{
			if (delegateObj == null)
			{
				throw new ArgumentNullException("delegateObj");
			}
			if (delegateObj.GetType().IsGenericType)
			{
				throw new InvalidOperationException($"The delegate type `{delegateObj.GetType()}` must be a non-generic type");
			}
			if (!methodInfo.IsStatic)
			{
				throw new InvalidOperationException($"The method `{methodInfo}` must be static. Instance methods are not supported");
			}
			if (methodInfo.IsGenericMethod)
			{
				throw new InvalidOperationException($"The method `{methodInfo}` must be a non-generic method");
			}
			Delegate @delegate = null;
			if (!isILPostProcessing)
			{
				@delegate = delegateObj as Delegate;
			}
			Delegate delegate2 = delegateObj as Delegate;
			if (BurstCompilerOptions.HasBurstCompileAttribute(methodInfo))
			{
				void* ptr;
				if (Options.EnableBurstCompilation && BurstCompilerHelper.IsBurstGenerated)
				{
					int num = BurstCompilerService.CompileAsyncDelegateMethod(delegateObj, string.Empty);
					ptr = BurstCompilerService.GetAsyncCompiledAsyncDelegateMethod(num);
				}
				else
				{
					if (isILPostProcessing)
					{
						return null;
					}
					GCHandle.Alloc(@delegate);
					ptr = (void*)Marshal.GetFunctionPointerForDelegate(@delegate);
				}
				if (ptr == null)
				{
					throw new InvalidOperationException($"Burst failed to compile the function pointer `{methodInfo}`");
				}
				return ptr;
			}
			throw new InvalidOperationException($"Burst cannot compile the function pointer `{methodInfo}` because the `[BurstCompile]` attribute is missing");
		}

		internal static void Shutdown()
		{
		}

		internal static void Cancel()
		{
		}

		internal static bool IsCurrentCompilationDone()
		{
			return true;
		}

		internal static void Enable()
		{
		}

		internal static void Disable()
		{
		}

		internal static bool IsHostEditorArm()
		{
			return false;
		}

		internal static void TriggerUnsafeStaticMethodRecompilation()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly element in assemblies)
			{
				IEnumerable<Attribute> enumerable = from x in element.GetCustomAttributes()
					where x.GetType().FullName == "Unity.Burst.BurstCompiler+StaticTypeReinitAttribute"
					select x;
				foreach (Attribute item in enumerable)
				{
					StaticTypeReinitAttribute staticTypeReinitAttribute = item as StaticTypeReinitAttribute;
					Type reinitType = staticTypeReinitAttribute.reinitType;
					MethodInfo method = reinitType.GetMethod("Constructor", BindingFlags.Static | BindingFlags.Public);
					method.Invoke(null, new object[0]);
				}
			}
		}

		internal static void TriggerRecompilation()
		{
		}

		internal static void UnloadAdditionalLibraries()
		{
			SendCommandToCompiler("$unload_burst_natives");
		}

		internal static void InitialiseDebuggerHooks()
		{
			if (IsApiAvailable("BurstManagedDebuggerPluginV1") && string.IsNullOrEmpty(Environment.GetEnvironmentVariable("BURST_DISABLE_DEBUGGER_HOOKS")))
			{
				SendCommandToCompiler(SendCommandToCompiler("$request_debug_command"));
			}
		}

		internal static bool IsApiAvailable(string apiName)
		{
			return SendCommandToCompiler("$is_native_api_available", apiName) == "True";
		}

		internal static int RequestSetProtocolVersion(int version)
		{
			string text = SendCommandToCompiler("$request_set_protocol_version_editor", $"{version}");
			if (string.IsNullOrEmpty(text) || !int.TryParse(text, out var result))
			{
				result = 0;
			}
			SendCommandToCompiler("$set_protocol_version_burst", $"{result}");
			return result;
		}

		internal static void Initialize(string[] assemblyFolders, string[] ignoreAssemblies)
		{
		}

		internal static void NotifyCompilationStarted(string[] assemblyFolders, string[] ignoreAssemblies)
		{
		}

		internal static void NotifyAssemblyCompilationNotRequired(string assemblyName)
		{
		}

		internal static void NotifyAssemblyCompilationFinished(string assemblyName, string[] defines)
		{
		}

		internal static void NotifyCompilationFinished()
		{
		}

		internal static string AotCompilation(string[] assemblyFolders, string[] assemblyRoots, string options)
		{
			return "failed";
		}

		internal static void SetProfilerCallbacks()
		{
		}

		private static string SendRawCommandToCompiler(string command)
		{
			string disassembly = BurstCompilerService.GetDisassembly(DummyMethodInfo, command);
			if (!string.IsNullOrEmpty(disassembly))
			{
				return disassembly.TrimStart('\n');
			}
			return "";
		}

		private static string SendCommandToCompiler(string commandName, string commandArgs = null)
		{
			if (commandName == null)
			{
				throw new ArgumentNullException("commandName");
			}
			if (commandArgs == null)
			{
				return SendRawCommandToCompiler(commandName);
			}
			return BeginCompilerCommand(commandName).With(commandArgs).SendToCompiler();
		}

		private static void DummyMethod()
		{
		}
	}
	internal enum GlobalSafetyChecksSettingKind
	{
		Off,
		On,
		ForceOn
	}
	public sealed class BurstCompilerOptions
	{
		private const string DisableCompilationArg = "--burst-disable-compilation";

		private const string ForceSynchronousCompilationArg = "--burst-force-sync-compilation";

		internal const string DefaultLibraryName = "lib_burst_generated";

		internal const string BurstInitializeName = "burst.initialize";

		internal const string BurstInitializeExternalsName = "burst.initialize.externals";

		internal const string BurstInitializeStaticsName = "burst.initialize.statics";

		internal const string OptionBurstcSwitch = "+burstc";

		internal const string OptionGroup = "group";

		internal const string OptionPlatform = "platform=";

		internal const string OptionBackend = "backend=";

		internal const string OptionGlobalSafetyChecksSetting = "global-safety-checks-setting=";

		internal const string OptionDisableSafetyChecks = "disable-safety-checks";

		internal const string OptionDisableOpt = "disable-opt";

		internal const string OptionFastMath = "fastmath";

		internal const string OptionTarget = "target=";

		internal const string OptionOptLevel = "opt-level=";

		internal const string OptionLogTimings = "log-timings";

		internal const string OptionOptForSize = "opt-for-size";

		internal const string OptionFloatPrecision = "float-precision=";

		internal const string OptionFloatMode = "float-mode=";

		internal const string OptionBranchProtection = "branch-protection=";

		internal const string OptionDisableWarnings = "disable-warnings=";

		internal const string OptionAssemblyDefines = "assembly-defines=";

		internal const string OptionDump = "dump=";

		internal const string OptionFormat = "format=";

		internal const string OptionDebugTrap = "debugtrap";

		internal const string OptionDisableVectors = "disable-vectors";

		internal const string OptionDebug = "debug=";

		internal const string OptionDebugMode = "debugMode";

		internal const string OptionStaticLinkage = "generate-static-linkage-methods";

		internal const string OptionJobMarshalling = "generate-job-marshalling-methods";

		internal const string OptionTempDirectory = "temp-folder=";

		internal const string OptionEnableDirectExternalLinking = "enable-direct-external-linking";

		internal const string OptionLinkerOptions = "linker-options=";

		internal const string OptionEnableAutoLayoutFallbackCheck = "enable-autolayout-fallback-check";

		internal const string OptionGenerateLinkXml = "generate-link-xml=";

		internal const string OptionMetaDataGeneration = "meta-data-generation=";

		internal const string OptionDisableStringInterpolationInExceptionMessages = "disable-string-interpolation-in-exception-messages";

		internal const string OptionPlatformConfiguration = "platform-configuration=";

		internal const string OptionCacheDirectory = "cache-directory=";

		internal const string OptionJitDisableFunctionCaching = "disable-function-caching";

		internal const string OptionJitDisableAssemblyCaching = "disable-assembly-caching";

		internal const string OptionJitEnableAssemblyCachingLogs = "enable-assembly-caching-logs";

		internal const string OptionJitEnableSynchronousCompilation = "enable-synchronous-compilation";

		internal const string OptionJitCompilationPriority = "compilation-priority=";

		internal const string OptionJitIsForFunctionPointer = "is-for-function-pointer";

		internal const string OptionJitManagedFunctionPointer = "managed-function-pointer=";

		internal const string OptionJitManagedDelegateHandle = "managed-delegate-handle=";

		internal const string OptionEnableInterpreter = "enable-interpreter";

		internal const string OptionAotAssemblyFolder = "assembly-folder=";

		internal const string OptionRootAssembly = "root-assembly=";

		internal const string OptionIncludeRootAssemblyReferences = "include-root-assembly-references=";

		internal const string OptionAotMethod = "method=";

		internal const string OptionAotType = "type=";

		internal const string OptionAotAssembly = "assembly=";

		internal const string OptionAotOutputPath = "output=";

		internal const string OptionAotKeepIntermediateFiles = "keep-intermediate-files";

		internal const string OptionAotNoLink = "nolink";

		internal const string OptionAotOnlyStaticMethods = "only-static-methods";

		internal const string OptionMethodPrefix = "method-prefix=";

		internal const string OptionAotNoNativeToolchain = "no-native-toolchain";

		internal const string OptionAotEmitLlvmObjects = "emit-llvm-objects";

		internal const string OptionAotKeyFolder = "key-folder=";

		internal const string OptionAotDecodeFolder = "decode-folder=";

		internal const string OptionVerbose = "verbose";

		internal const string OptionValidateExternalToolChain = "validate-external-tool-chain";

		internal const string OptionCompilerThreads = "threads=";

		internal const string OptionChunkSize = "chunk-size=";

		internal const string OptionPrintLogOnMissingPInvokeCallbackAttribute = "print-monopinvokecallbackmissing-message";

		internal const string OptionOutputMode = "output-mode=";

		internal const string OptionAlwaysCreateOutput = "always-create-output=";

		internal const string OptionAotPdbSearchPaths = "pdb-search-paths=";

		internal const string OptionSafetyChecks = "safety-checks";

		internal const string OptionLibraryOutputMode = "library-output-mode=";

		internal const string OptionCompilationId = "compilation-id=";

		internal const string OptionTargetFramework = "target-framework=";

		internal const string OptionDiscardAssemblies = "discard-assemblies=";

		internal const string OptionSaveExtraContext = "save-extra-context";

		internal const string CompilerCommandShutdown = "$shutdown";

		internal const string CompilerCommandCancel = "$cancel";

		internal const string CompilerCommandEnableCompiler = "$enable_compiler";

		internal const string CompilerCommandDisableCompiler = "$disable_compiler";

		internal const string CompilerCommandSetDefaultOptions = "$set_default_options";

		internal const string CompilerCommandTriggerSetupRecompilation = "$trigger_setup_recompilation";

		internal const string CompilerCommandIsCurrentCompilationDone = "$is_current_compilation_done";

		internal const string CompilerCommandTriggerRecompilation = "$trigger_recompilation";

		internal const string CompilerCommandInitialize = "$initialize";

		internal const string CompilerCommandDomainReload = "$domain_reload";

		internal const string CompilerCommandVersionNotification = "$version";

		internal const string CompilerCommandGetTargetCpuFromHost = "$get_target_cpu_from_host";

		internal const string CompilerCommandSetProfileCallbacks = "$set_profile_callbacks";

		internal const string CompilerCommandUnloadBurstNatives = "$unload_burst_natives";

		internal const string CompilerCommandIsNativeApiAvailable = "$is_native_api_available";

		internal const string CompilerCommandILPPCompilation = "$ilpp_compilation";

		internal const string CompilerCommandIsArmTestEnv = "$is_arm_test_env";

		internal const string CompilerCommandNotifyAssemblyCompilationNotRequired = "$notify_assembly_compilation_not_required";

		internal const string CompilerCommandNotifyAssemblyCompilationFinished = "$notify_assembly_compilation_finished";

		internal const string CompilerCommandNotifyCompilationStarted = "$notify_compilation_started";

		internal const string CompilerCommandNotifyCompilationFinished = "$notify_compilation_finished";

		internal const string CompilerCommandAotCompilation = "$aot_compilation";

		internal const string CompilerCommandRequestInitialiseDebuggerCommmand = "$request_debug_command";

		internal const string CompilerCommandInitialiseDebuggerCommmand = "$load_debugger_interface";

		internal const string CompilerCommandRequestSetProtocolVersionEditor = "$request_set_protocol_version_editor";

		internal const string CompilerCommandSetProtocolVersionBurst = "$set_protocol_version_burst";

		internal static readonly bool ForceDisableBurstCompilation;

		private static readonly bool ForceBurstCompilationSynchronously;

		internal static readonly bool IsSecondaryUnityProcess;

		private bool _enableBurstCompilation;

		private bool _enableBurstCompileSynchronously;

		private bool _enableBurstSafetyChecks;

		private bool _enableBurstTimings;

		private bool _enableBurstDebug;

		private bool _forceEnableBurstSafetyChecks;

		private bool IsGlobal { get; }

		public bool IsEnabled => EnableBurstCompilation && !ForceDisableBurstCompilation;

		public bool EnableBurstCompilation
		{
			get
			{
				return _enableBurstCompilation;
			}
			set
			{
				if (IsGlobal && ForceDisableBurstCompilation)
				{
					value = false;
				}
				bool flag = _enableBurstCompilation != value;
				_enableBurstCompilation = value;
				if (IsGlobal)
				{
					JobsUtility.JobCompilerEnabled = value;
					BurstCompiler._IsEnabled = value;
				}
				if (flag)
				{
					OnOptionsChanged();
				}
			}
		}

		public bool EnableBurstCompileSynchronously
		{
			get
			{
				return _enableBurstCompileSynchronously;
			}
			set
			{
				bool flag = _enableBurstCompileSynchronously != value;
				_enableBurstCompileSynchronously = value;
				if (flag)
				{
					OnOptionsChanged();
				}
			}
		}

		public bool EnableBurstSafetyChecks
		{
			get
			{
				return _enableBurstSafetyChecks;
			}
			set
			{
				bool flag = _enableBurstSafetyChecks != value;
				_enableBurstSafetyChecks = value;
				if (flag)
				{
					OnOptionsChanged();
					MaybeTriggerRecompilation();
				}
			}
		}

		public bool ForceEnableBurstSafetyChecks
		{
			get
			{
				return _forceEnableBurstSafetyChecks;
			}
			set
			{
				bool flag = _forceEnableBurstSafetyChecks != value;
				_forceEnableBurstSafetyChecks = value;
				if (flag)
				{
					OnOptionsChanged();
					MaybeTriggerRecompilation();
				}
			}
		}

		public bool EnableBurstDebug
		{
			get
			{
				return _enableBurstDebug;
			}
			set
			{
				bool flag = _enableBurstDebug != value;
				_enableBurstDebug = value;
				if (flag)
				{
					OnOptionsChanged();
					MaybeTriggerRecompilation();
				}
			}
		}

		[Obsolete("This property is no longer used and will be removed in a future major release")]
		public bool DisableOptimizations
		{
			get
			{
				return false;
			}
			set
			{
			}
		}

		[Obsolete("This property is no longer used and will be removed in a future major release. Use the [BurstCompile(FloatMode = FloatMode.Fast)] on the method directly to enable this feature")]
		public bool EnableFastMath
		{
			get
			{
				return true;
			}
			set
			{
			}
		}

		internal bool EnableBurstTimings
		{
			get
			{
				return _enableBurstTimings;
			}
			set
			{
				bool flag = _enableBurstTimings != value;
				_enableBurstTimings = value;
				if (flag)
				{
					OnOptionsChanged();
				}
			}
		}

		internal bool RequiresSynchronousCompilation => EnableBurstCompileSynchronously || ForceBurstCompilationSynchronously;

		internal Action OptionsChanged { get; set; }

		internal static string SerialiseCompilationOptionsSafe(string[] roots, string[] folders, string options)
		{
			return SafeStringArrayHelper.SerialiseStringArraySafe(new string[3]
			{
				SafeStringArrayHelper.SerialiseStringArraySafe(roots),
				SafeStringArrayHelper.SerialiseStringArraySafe(folders),
				options
			});
		}

		internal static (string[] roots, string[] folders, string options) DeserialiseCompilationOptionsSafe(string from)
		{
			string[] array = SafeStringArrayHelper.DeserialiseStringArraySafe(from);
			return (SafeStringArrayHelper.DeserialiseStringArraySafe(array[0]), SafeStringArrayHelper.DeserialiseStringArraySafe(array[1]), array[2]);
		}

		private BurstCompilerOptions()
			: this(isGlobal: false)
		{
		}

		internal BurstCompilerOptions(bool isGlobal)
		{
			try
			{
				IsGlobal = isGlobal;
				EnableBurstCompilation = true;
				EnableBurstSafetyChecks = true;
			}
			finally
			{
			}
		}

		internal BurstCompilerOptions Clone()
		{
			return new BurstCompilerOptions
			{
				EnableBurstCompilation = EnableBurstCompilation,
				EnableBurstCompileSynchronously = EnableBurstCompileSynchronously,
				EnableBurstSafetyChecks = EnableBurstSafetyChecks,
				EnableBurstTimings = EnableBurstTimings,
				EnableBurstDebug = EnableBurstDebug,
				ForceEnableBurstSafetyChecks = ForceEnableBurstSafetyChecks
			};
		}

		private static bool TryGetAttribute(MemberInfo member, out BurstCompileAttribute attribute)
		{
			attribute = null;
			if (member == null)
			{
				return false;
			}
			attribute = GetBurstCompileAttribute(member);
			if (attribute == null)
			{
				return false;
			}
			return true;
		}

		private static bool TryGetAttribute(Assembly assembly, out BurstCompileAttribute attribute)
		{
			if (assembly == null)
			{
				attribute = null;
				return false;
			}
			attribute = assembly.GetCustomAttribute<BurstCompileAttribute>();
			return attribute != null;
		}

		private static BurstCompileAttribute GetBurstCompileAttribute(MemberInfo memberInfo)
		{
			BurstCompileAttribute customAttribute = memberInfo.GetCustomAttribute<BurstCompileAttribute>();
			if (customAttribute != null)
			{
				return customAttribute;
			}
			foreach (Attribute customAttribute2 in memberInfo.GetCustomAttributes())
			{
				Type type = customAttribute2.GetType();
				if (type.FullName == "Burst.Compiler.IL.Tests.TestCompilerAttribute")
				{
					List<string> list = new List<string>();
					return new BurstCompileAttribute(FloatPrecision.Standard, FloatMode.Default)
					{
						CompileSynchronously = true,
						Options = list.ToArray()
					};
				}
			}
			return null;
		}

		internal static bool HasBurstCompileAttribute(MemberInfo member)
		{
			if (member == null)
			{
				throw new ArgumentNullException("member");
			}
			BurstCompileAttribute attribute;
			return TryGetAttribute(member, out attribute);
		}

		internal static void MergeAttributes(ref BurstCompileAttribute memberAttribute, in BurstCompileAttribute assemblyAttribute)
		{
			if (memberAttribute.FloatMode == FloatMode.Default)
			{
				memberAttribute.FloatMode = assemblyAttribute.FloatMode;
			}
			if (memberAttribute.FloatPrecision == FloatPrecision.Standard)
			{
				memberAttribute.FloatPrecision = assemblyAttribute.FloatPrecision;
			}
			if (memberAttribute.OptimizeFor == OptimizeFor.Default)
			{
				memberAttribute.OptimizeFor = assemblyAttribute.OptimizeFor;
			}
			if (!memberAttribute._compileSynchronously.HasValue && assemblyAttribute._compileSynchronously.HasValue)
			{
				memberAttribute._compileSynchronously = assemblyAttribute._compileSynchronously;
			}
			if (!memberAttribute._debug.HasValue && assemblyAttribute._debug.HasValue)
			{
				memberAttribute._debug = assemblyAttribute._debug;
			}
			if (!memberAttribute._disableDirectCall.HasValue && assemblyAttribute._disableDirectCall.HasValue)
			{
				memberAttribute._disableDirectCall = assemblyAttribute._disableDirectCall;
			}
			if (!memberAttribute._disableSafetyChecks.HasValue && assemblyAttribute._disableSafetyChecks.HasValue)
			{
				memberAttribute._disableSafetyChecks = assemblyAttribute._disableSafetyChecks;
			}
		}

		internal bool TryGetOptions(MemberInfo member, out string flagsOut, bool isForILPostProcessing = false, bool isForCompilerClient = false)
		{
			flagsOut = null;
			if (!TryGetAttribute(member, out var attribute))
			{
				return false;
			}
			if (TryGetAttribute(member.Module.Assembly, out var attribute2))
			{
				MergeAttributes(ref attribute, in attribute2);
			}
			flagsOut = GetOptions(attribute, isForILPostProcessing, isForCompilerClient);
			return true;
		}

		internal string GetOptions(BurstCompileAttribute attr = null, bool isForILPostProcessing = false, bool isForCompilerClient = false)
		{
			StringBuilder stringBuilder = new StringBuilder();
			if (!isForCompilerClient && ((attr != null && attr.CompileSynchronously) || RequiresSynchronousCompilation))
			{
				AddOption(stringBuilder, GetOption("enable-synchronous-compilation"));
			}
			AddOption(stringBuilder, GetOption("debug=", "LineOnly"));
			if (isForILPostProcessing)
			{
				AddOption(stringBuilder, GetOption("compilation-priority=", CompilationPriority.ILPP));
			}
			if (attr != null)
			{
				if (attr.FloatMode != 0)
				{
					AddOption(stringBuilder, GetOption("float-mode=", attr.FloatMode));
				}
				if (attr.FloatPrecision != 0)
				{
					AddOption(stringBuilder, GetOption("float-precision=", attr.FloatPrecision));
				}
				if (attr.DisableSafetyChecks)
				{
					AddOption(stringBuilder, GetOption("disable-safety-checks"));
				}
				if (attr.Options != null)
				{
					string[] options = attr.Options;
					foreach (string text in options)
					{
						if (!string.IsNullOrEmpty(text))
						{
							AddOption(stringBuilder, text);
						}
					}
				}
				switch (attr.OptimizeFor)
				{
				case OptimizeFor.Default:
				case OptimizeFor.Balanced:
					AddOption(stringBuilder, GetOption("opt-level=", 2));
					break;
				case OptimizeFor.Performance:
					AddOption(stringBuilder, GetOption("opt-level=", 3));
					break;
				case OptimizeFor.Size:
					AddOption(stringBuilder, GetOption("opt-for-size"));
					AddOption(stringBuilder, GetOption("opt-level=", 3));
					break;
				case OptimizeFor.FastCompilation:
					AddOption(stringBuilder, GetOption("opt-level=", 1));
					break;
				}
			}
			if (ForceEnableBurstSafetyChecks)
			{
				AddOption(stringBuilder, GetOption("global-safety-checks-setting=", GlobalSafetyChecksSettingKind.ForceOn));
			}
			else if (EnableBurstSafetyChecks)
			{
				AddOption(stringBuilder, GetOption("global-safety-checks-setting=", GlobalSafetyChecksSettingKind.On));
			}
			else
			{
				AddOption(stringBuilder, GetOption("global-safety-checks-setting=", GlobalSafetyChecksSettingKind.Off));
			}
			if (EnableBurstTimings)
			{
				AddOption(stringBuilder, GetOption("log-timings"));
			}
			if (EnableBurstDebug || (attr != null && attr.Debug))
			{
				AddOption(stringBuilder, GetOption("debugMode"));
			}
			AddOption(stringBuilder, GetOption("temp-folder=", Path.Combine(Environment.CurrentDirectory, "Temp", "Burst")));
			return stringBuilder.ToString();
		}

		private static void AddOption(StringBuilder builder, string option)
		{
			if (builder.Length != 0)
			{
				builder.Append('\n');
			}
			builder.Append(option);
		}

		internal static string GetOption(string optionName, object value = null)
		{
			if (optionName == null)
			{
				throw new ArgumentNullException("optionName");
			}
			return "--" + optionName + (value ?? string.Empty);
		}

		private void OnOptionsChanged()
		{
			OptionsChanged?.Invoke();
		}

		private void MaybeTriggerRecompilation()
		{
		}

		static BurstCompilerOptions()
		{
			string[] commandLineArgs = Environment.GetCommandLineArgs();
			foreach (string text in commandLineArgs)
			{
				string text2 = text;
				string text3 = text2;
				if (!(text3 == "--burst-disable-compilation"))
				{
					if (text3 == "--burst-force-sync-compilation")
					{
						ForceBurstCompilationSynchronously = true;
					}
				}
				else
				{
					ForceDisableBurstCompilation = true;
				}
			}
			if (CheckIsSecondaryUnityProcess())
			{
				ForceDisableBurstCompilation = true;
				IsSecondaryUnityProcess = true;
			}
			string environmentVariable = Environment.GetEnvironmentVariable("UNITY_BURST_DISABLE_COMPILATION");
			if (!string.IsNullOrEmpty(environmentVariable) && environmentVariable != "0")
			{
				ForceDisableBurstCompilation = true;
			}
		}

		private static bool CheckIsSecondaryUnityProcess()
		{
			return false;
		}
	}
	internal enum BurstTargetCpu
	{
		Auto,
		X86_SSE2,
		X86_SSE4,
		X64_SSE2,
		X64_SSE4,
		AVX,
		AVX2,
		WASM32,
		ARMV7A_NEON32,
		ARMV8A_AARCH64,
		THUMB2_NEON32,
		ARMV8A_AARCH64_HALFFP,
		ARMV9A
	}
	[Flags]
	internal enum NativeDumpFlags
	{
		None = 0,
		IL = 1,
		Unused = 2,
		IR = 4,
		IROptimized = 8,
		Asm = 0x10,
		Function = 0x20,
		Analysis = 0x40,
		IRPassAnalysis = 0x80,
		ILPre = 0x100,
		IRPerEntryPoint = 0x200,
		All = 0x3FD
	}
	internal enum CompilationPriority
	{
		EagerCompilationSynchronous,
		Asynchronous,
		ILPP,
		EagerCompilationAsynchronous
	}
	public enum BurstExecutionEnvironment
	{
		Default = 0,
		NonDeterministic = 0,
		Deterministic = 1
	}
	public static class BurstRuntime
	{
		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct HashCode32<T>
		{
			public static readonly int Value = HashStringWithFNV1A32(typeof(T).AssemblyQualifiedName);
		}

		[StructLayout(LayoutKind.Sequential, Size = 1)]
		private struct HashCode64<T>
		{
			public static readonly long Value = HashStringWithFNV1A64(typeof(T).AssemblyQualifiedName);
		}

		internal class PreserveAttribute : Attribute
		{
		}

		public static int GetHashCode32<T>()
		{
			return HashCode32<T>.Value;
		}

		public static int GetHashCode32(Type type)
		{
			return HashStringWithFNV1A32(type.AssemblyQualifiedName);
		}

		public static long GetHashCode64<T>()
		{
			return HashCode64<T>.Value;
		}

		public static long GetHashCode64(Type type)
		{
			return HashStringWithFNV1A64(type.AssemblyQualifiedName);
		}

		internal static int HashStringWithFNV1A32(string text)
		{
			uint num = 2166136261u;
			foreach (char c in text)
			{
				num = 16777619 * (num ^ (byte)(c & 0xFF));
				num = 16777619 * (num ^ (byte)((int)c >> 8));
			}
			return (int)num;
		}

		internal static long HashStringWithFNV1A64(string text)
		{
			ulong num = 14695981039346656037uL;
			foreach (char c in text)
			{
				num = 1099511628211L * (num ^ (byte)(c & 0xFF));
				num = 1099511628211L * (num ^ (byte)((int)c >> 8));
			}
			return (long)num;
		}

		public static bool LoadAdditionalLibrary(string pathToLibBurstGenerated)
		{
			if (BurstCompiler.IsLoadAdditionalLibrarySupported())
			{
				return LoadAdditionalLibraryInternal(pathToLibBurstGenerated);
			}
			return false;
		}

		internal static bool LoadAdditionalLibraryInternal(string pathToLibBurstGenerated)
		{
			return (bool)typeof(BurstCompilerService).GetMethod("LoadBurstLibrary").Invoke(null, new object[1] { pathToLibBurstGenerated });
		}

		internal static void Initialize()
		{
		}

		[Preserve]
		internal static void PreventRequiredAttributeStrip()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			new BurstDiscardAttribute();
			new ConditionalAttribute("HEJSA");
			new JobProducerTypeAttribute(typeof(BurstRuntime));
		}

		[Preserve]
		internal unsafe static void Log(byte* message, int logType, byte* fileName, int lineNumber)
		{
			BurstCompilerService.Log((void*)null, (BurstLogType)logType, message, (byte*)null, lineNumber);
		}

		public unsafe static byte* GetUTF8LiteralPointer(string str, out int byteCount)
		{
			throw new NotImplementedException("This function only works from Burst");
		}
	}
	internal static class BurstString
	{
		internal class PreserveAttribute : Attribute
		{
		}

		private enum NumberBufferKind
		{
			Integer,
			Float
		}

		private struct NumberBuffer
		{
			private unsafe readonly byte* _buffer;

			public NumberBufferKind Kind;

			public int DigitsCount;

			public int Scale;

			public readonly bool IsNegative;

			public unsafe NumberBuffer(NumberBufferKind kind, byte* buffer, int digitsCount, int scale, bool isNegative)
			{
				Kind = kind;
				_buffer = buffer;
				DigitsCount = digitsCount;
				Scale = scale;
				IsNegative = isNegative;
			}

			public unsafe byte* GetDigitsPointer()
			{
				return _buffer;
			}
		}

		public enum NumberFormatKind : byte
		{
			General,
			Decimal,
			DecimalForceSigned,
			Hexadecimal
		}

		public struct FormatOptions
		{
			public NumberFormatKind Kind;

			public sbyte AlignAndSize;

			public byte Specifier;

			public bool Lowercase;

			public bool Uppercase => !Lowercase;

			public FormatOptions(NumberFormatKind kind, sbyte alignAndSize, byte specifier, bool lowercase)
			{
				this = default(FormatOptions);
				Kind = kind;
				AlignAndSize = alignAndSize;
				Specifier = specifier;
				Lowercase = lowercase;
			}

			public unsafe int EncodeToRaw()
			{
				Debug.Assert(sizeof(FormatOptions) == 4);
				FormatOptions formatOptions = this;
				return *(int*)(&formatOptions);
			}

			public int GetBase()
			{
				NumberFormatKind kind = Kind;
				NumberFormatKind numberFormatKind = kind;
				if (numberFormatKind == NumberFormatKind.Hexadecimal)
				{
					return 16;
				}
				return 10;
			}

			public override string ToString()
			{
				return string.Format("{0}: {1}, {2}: {3}, {4}: {5}, {6}: {7}", "Kind", Kind, "AlignAndSize", AlignAndSize, "Specifier", Specifier, "Uppercase", Uppercase);
			}
		}

		public struct tBigInt
		{
			private const int c_BigInt_MaxBlocks = 35;

			public int m_length;

			public unsafe fixed uint m_blocks[35];

			public int GetLength()
			{
				return m_length;
			}

			public unsafe uint GetBlock(int idx)
			{
				return m_blocks[idx];
			}

			public void SetZero()
			{
				m_length = 0;
			}

			public bool IsZero()
			{
				return m_length == 0;
			}

			public unsafe void SetU64(ulong val)
			{
				if (val > uint.MaxValue)
				{
					m_blocks[0] = (uint)(val & 0xFFFFFFFFu);
					m_blocks[1] = (uint)((val >> 32) & 0xFFFFFFFFu);
					m_length = 2;
				}
				else if (val != 0)
				{
					m_blocks[0] = (uint)(val & 0xFFFFFFFFu);
					m_length = 1;
				}
				else
				{
					m_length = 0;
				}
			}

			public unsafe void SetU32(uint val)
			{
				if (val != 0)
				{
					m_blocks[0] = val;
					m_length = ((val != 0) ? 1 : 0);
				}
				else
				{
					m_length = 0;
				}
			}

			public unsafe uint GetU32()
			{
				return (m_length != 0) ? m_blocks[0] : 0u;
			}
		}

		public enum CutoffMode
		{
			Unique,
			TotalLength,
			FractionLength
		}

		public enum PrintFloatFormat
		{
			Positional,
			Scientific
		}

		[StructLayout(LayoutKind.Explicit)]
		public struct tFloatUnion32
		{
			[FieldOffset(0)]
			public float m_floatingPoint;

			[FieldOffset(0)]
			public uint m_integer;

			public bool IsNegative()
			{
				return m_integer >> 31 != 0;
			}

			public uint GetExponent()
			{
				return (m_integer >> 23) & 0xFFu;
			}

			public uint GetMantissa()
			{
				return m_integer & 0x7FFFFFu;
			}
		}

		[StructLayout(LayoutKind.Explicit)]
		public struct tFloatUnion64
		{
			[FieldOffset(0)]
			public double m_floatingPoint;

			[FieldOffset(0)]
			public ulong m_integer;

			public bool IsNegative()
			{
				return m_integer >> 63 != 0;
			}

			public uint GetExponent()
			{
				return (uint)((m_integer >> 52) & 0x7FF);
			}

			public ulong GetMantissa()
			{
				return m_integer & 0xFFFFFFFFFFFFFuL;
			}
		}

		private static readonly char[] SplitByColon = new char[1] { ':' };

		private static readonly byte[] logTable = new byte[256]
		{
			0, 0, 1, 1, 2, 2, 2, 2, 3, 3,
			3, 3, 3, 3, 3, 3, 4, 4, 4, 4,
			4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
			4, 4, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
			5, 5, 5, 5, 6, 6, 6, 6, 6, 6,
			6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
			6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
			6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
			6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
			6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
			6, 6, 6, 6, 6, 6, 6, 6, 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, 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, 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, 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,
			7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
			7, 7, 7, 7, 7, 7
		};

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

		private static readonly byte[] InfinityString = new byte[8] { 73, 110, 102, 105, 110, 105, 116, 121 };

		private static readonly byte[] NanString = new byte[3] { 78, 97, 78 };

		private const int SinglePrecision = 9;

		private const int DoublePrecision = 17;

		internal const int SingleNumberBufferLength = 10;

		internal const int DoubleNumberBufferLength = 18;

		private const int SinglePrecisionCustomFormat = 7;

		private const int DoublePrecisionCustomFormat = 15;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Preserve]
		public unsafe static void CopyFixedString(byte* dest, int destLength, byte* src, int srcLength)
		{
			int num = ((srcLength > destLength) ? destLength : srcLength);
			*(ushort*)(dest - 2) = (ushort)num;
			dest[num] = 0;
			UnsafeUtility.MemCpy((void*)dest, (void*)src, (long)num);
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, byte* src, int srcLength, int formatOptionsRaw)
		{
			FormatOptions formatOptions = *(FormatOptions*)(&formatOptionsRaw);
			if (!AlignLeft(dest, ref destIndex, destLength, formatOptions.AlignAndSize, srcLength))
			{
				int num = destLength - destIndex;
				int num2 = ((srcLength > num) ? num : srcLength);
				if (num2 > 0)
				{
					UnsafeUtility.MemCpy((void*)(dest + destIndex), (void*)src, (long)num2);
					destIndex += num2;
					AlignRight(dest, ref destIndex, destLength, formatOptions.AlignAndSize, srcLength);
				}
			}
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, float value, int formatOptionsRaw)
		{
			FormatOptions formatOptions = *(FormatOptions*)(&formatOptionsRaw);
			ConvertFloatToString(dest, ref destIndex, destLength, value, formatOptions);
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, double value, int formatOptionsRaw)
		{
			FormatOptions formatOptions = *(FormatOptions*)(&formatOptionsRaw);
			ConvertDoubleToString(dest, ref destIndex, destLength, value, formatOptions);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, bool value, int formatOptionsRaw)
		{
			int length = (value ? 4 : 5);
			FormatOptions formatOptions = *(FormatOptions*)(&formatOptionsRaw);
			if (AlignLeft(dest, ref destIndex, destLength, formatOptions.AlignAndSize, length))
			{
				return;
			}
			if (value)
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 84;
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 114;
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 117;
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 101;
			}
			else
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 70;
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 97;
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 108;
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 115;
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 101;
			}
			AlignRight(dest, ref destIndex, destLength, formatOptions.AlignAndSize, length);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, char value, int formatOptionsRaw)
		{
			int num = ((value <= '\u007f') ? 1 : ((value <= '߿') ? 2 : 3));
			FormatOptions formatOptions = *(FormatOptions*)(&formatOptionsRaw);
			if (AlignLeft(dest, ref destIndex, destLength, formatOptions.AlignAndSize, 1))
			{
				return;
			}
			switch (num)
			{
			case 1:
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = (byte)value;
				break;
			case 2:
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = (byte)((uint)((int)value >> 6) | 0xC0u);
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = (byte)((value & 0x3Fu) | 0x80u);
				break;
			case 3:
				if (value >= '\ud800' && value <= '\udfff')
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = 239;
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = 191;
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = 189;
				}
				else
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = (byte)((uint)((int)value >> 12) | 0xE0u);
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = (byte)(((uint)((int)value >> 6) & 0x3Fu) | 0x80u);
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = (byte)((value & 0x3Fu) | 0x80u);
				}
				break;
			}
			AlignRight(dest, ref destIndex, destLength, formatOptions.AlignAndSize, 1);
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, byte value, int formatOptionsRaw)
		{
			Format(dest, ref destIndex, destLength, (ulong)value, formatOptionsRaw);
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, ushort value, int formatOptionsRaw)
		{
			Format(dest, ref destIndex, destLength, (ulong)value, formatOptionsRaw);
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, uint value, int formatOptionsRaw)
		{
			FormatOptions options = *(FormatOptions*)(&formatOptionsRaw);
			ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, value, options);
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, ulong value, int formatOptionsRaw)
		{
			FormatOptions options = *(FormatOptions*)(&formatOptionsRaw);
			ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, value, options);
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, sbyte value, int formatOptionsRaw)
		{
			FormatOptions options = *(FormatOptions*)(&formatOptionsRaw);
			if (options.Kind == NumberFormatKind.Hexadecimal)
			{
				ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (byte)value, options);
			}
			else
			{
				ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
			}
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, short value, int formatOptionsRaw)
		{
			FormatOptions options = *(FormatOptions*)(&formatOptionsRaw);
			if (options.Kind == NumberFormatKind.Hexadecimal)
			{
				ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (ushort)value, options);
			}
			else
			{
				ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, int value, int formatOptionsRaw)
		{
			FormatOptions options = *(FormatOptions*)(&formatOptionsRaw);
			if (options.Kind == NumberFormatKind.Hexadecimal)
			{
				ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (uint)value, options);
			}
			else
			{
				ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
			}
		}

		[Preserve]
		public unsafe static void Format(byte* dest, ref int destIndex, int destLength, long value, int formatOptionsRaw)
		{
			FormatOptions options = *(FormatOptions*)(&formatOptionsRaw);
			if (options.Kind == NumberFormatKind.Hexadecimal)
			{
				ConvertUnsignedIntegerToString(dest, ref destIndex, destLength, (ulong)value, options);
			}
			else
			{
				ConvertIntegerToString(dest, ref destIndex, destLength, value, options);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe static void ConvertUnsignedIntegerToString(byte* dest, ref int destIndex, int destLength, ulong value, FormatOptions options)
		{
			uint @base = (uint)options.GetBase();
			if (@base >= 2 && @base <= 36)
			{
				int num = 0;
				ulong num2 = value;
				do
				{
					num2 /= @base;
					num++;
				}
				while (num2 != 0);
				int num3 = num - 1;
				byte* ptr = stackalloc byte[(int)(uint)(num + 1)];
				num2 = value;
				do
				{
					ptr[num3--] = ValueToIntegerChar((int)(num2 % @base), options.Uppercase);
					num2 /= @base;
				}
				while (num2 != 0);
				ptr[num] = 0;
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, ptr, num, num, isNegative: false);
				FormatNumber(dest, ref destIndex, destLength, ref number, options.Specifier, options);
			}
		}

		private static int GetLengthIntegerToString(long value, int basis, int zeroPadding)
		{
			int num = 0;
			long num2 = value;
			do
			{
				num2 /= basis;
				num++;
			}
			while (num2 != 0);
			if (num < zeroPadding)
			{
				num = zeroPadding;
			}
			if (value < 0)
			{
				num++;
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe static void ConvertIntegerToString(byte* dest, ref int destIndex, int destLength, long value, FormatOptions options)
		{
			int @base = options.GetBase();
			if (@base >= 2 && @base <= 36)
			{
				int num = 0;
				long num2 = value;
				do
				{
					num2 /= @base;
					num++;
				}
				while (num2 != 0);
				byte* ptr = stackalloc byte[(int)(uint)(num + 1)];
				num2 = value;
				int num3 = num - 1;
				do
				{
					ptr[num3--] = ValueToIntegerChar((int)(num2 % @base), options.Uppercase);
					num2 /= @base;
				}
				while (num2 != 0);
				ptr[num] = 0;
				NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, ptr, num, num, value < 0);
				FormatNumber(dest, ref destIndex, destLength, ref number, options.Specifier, options);
			}
		}

		private unsafe static void FormatNumber(byte* dest, ref int destIndex, int destLength, ref NumberBuffer number, int nMaxDigits, FormatOptions options)
		{
			bool isCorrectlyRounded = number.Kind == NumberBufferKind.Float;
			if (number.Kind == NumberBufferKind.Integer && options.Kind == NumberFormatKind.General && options.Specifier == 0)
			{
				options.Kind = NumberFormatKind.Decimal;
			}
			NumberFormatKind kind = options.Kind;
			NumberFormatKind numberFormatKind = kind;
			if (numberFormatKind != 0 && numberFormatKind - 1 <= NumberFormatKind.DecimalForceSigned)
			{
				int num = number.DigitsCount;
				int specifier = options.Specifier;
				int zeroPadding = 0;
				if (num < specifier)
				{
					zeroPadding = specifier - num;
					num = specifier;
				}
				bool flag = options.Kind == NumberFormatKind.DecimalForceSigned;
				num += ((number.IsNegative || flag) ? 1 : 0);
				if (!AlignLeft(dest, ref destIndex, destLength, options.AlignAndSize, num))
				{
					FormatDecimalOrHexadecimal(dest, ref destIndex, destLength, ref number, zeroPadding, flag);
					AlignRight(dest, ref destIndex, destLength, options.AlignAndSize, num);
				}
			}
			else
			{
				if (nMaxDigits < 1)
				{
					nMaxDigits = number.DigitsCount;
				}
				RoundNumber(ref number, nMaxDigits, isCorrectlyRounded);
				int num = GetLengthForFormatGeneral(ref number, nMaxDigits);
				if (!AlignLeft(dest, ref destIndex, destLength, options.AlignAndSize, num))
				{
					FormatGeneral(dest, ref destIndex, destLength, ref number, nMaxDigits, (byte)(options.Uppercase ? 69 : 101));
					AlignRight(dest, ref destIndex, destLength, options.AlignAndSize, num);
				}
			}
		}

		private unsafe static void FormatDecimalOrHexadecimal(byte* dest, ref int destIndex, int destLength, ref NumberBuffer number, int zeroPadding, bool outputPositiveSign)
		{
			if (number.IsNegative)
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 45;
			}
			else if (outputPositiveSign)
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 43;
			}
			for (int i = 0; i < zeroPadding; i++)
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 48;
			}
			int digitsCount = number.DigitsCount;
			byte* digitsPointer = number.GetDigitsPointer();
			for (int j = 0; j < digitsCount; j++)
			{
				if (destIndex >= destLength)
				{
					break;
				}
				dest[destIndex++] = digitsPointer[j];
			}
		}

		private static byte ValueToIntegerChar(int value, bool uppercase)
		{
			value = ((value < 0) ? (-value) : value);
			if (value <= 9)
			{
				return (byte)(48 + value);
			}
			if (value < 36)
			{
				return (byte)((uppercase ? 65 : 97) + (value - 10));
			}
			return 63;
		}

		private static void OptsSplit(string fullFormat, out string padding, out string format)
		{
			string[] array = fullFormat.Split(SplitByColon, StringSplitOptions.RemoveEmptyEntries);
			format = array[0];
			padding = null;
			if (array.Length == 2)
			{
				padding = format;
				format = array[1];
				return;
			}
			if (array.Length == 1)
			{
				if (format[0] == ',')
				{
					padding = format;
					format = null;
				}
				return;
			}
			throw new ArgumentException($"Format `{format}` not supported. Invalid number {array.Length} of :. Expecting no more than one.");
		}

		public static FormatOptions ParseFormatToFormatOptions(string fullFormat)
		{
			if (string.IsNullOrWhiteSpace(fullFormat))
			{
				return default(FormatOptions);
			}
			OptsSplit(fullFormat, out var padding, out var format);
			format = format?.Trim();
			padding = padding?.Trim();
			int result = 0;
			NumberFormatKind kind = NumberFormatKind.General;
			bool lowercase = false;
			int num = 0;
			if (!string.IsNullOrEmpty(format))
			{
				switch (format[0])
				{
				case 'G':
					kind = NumberFormatKind.General;
					break;
				case 'g':
					kind = NumberFormatKind.General;
					lowercase = true;
					break;
				case 'D':
					kind = NumberFormatKind.Decimal;
					break;
				case 'd':
					kind = NumberFormatKind.Decimal;
					lowercase = true;
					break;
				case 'X':
					kind = NumberFormatKind.Hexadecimal;
					break;
				case 'x':
					kind = NumberFormatKind.Hexadecimal;
					lowercase = true;
					break;
				default:
					throw new ArgumentException("Format `" + format + "` not supported. Only G, g, D, d, X, x are supported.");
				}
				if (format.Length > 1)
				{
					string text = format.Substring(1);
					if (!uint.TryParse(text, out var result2))
					{
						throw new ArgumentException("Expecting an unsigned integer for specifier `" + format + "` instead of " + text + ".");
					}
					num = (int)result2;
				}
			}
			if (!string.IsNullOrEmpty(padding))
			{
				if (padding[0] != ',')
				{
					throw new ArgumentException("Invalid padding `" + padding + "`, expecting to start with a leading `,` comma.");
				}
				string text2 = padding.Substring(1);
				if (!int.TryParse(text2, out result))
				{
					throw new ArgumentException("Expecting an integer for align/size padding `" + text2 + "`.");
				}
			}
			return new FormatOptions(kind, (sbyte)result, (byte)num, lowercase);
		}

		private unsafe static bool AlignRight(byte* dest, ref int destIndex, int destLength, int align, int length)
		{
			if (align < 0)
			{
				align = -align;
				return AlignLeft(dest, ref destIndex, destLength, align, length);
			}
			return false;
		}

		private unsafe static bool AlignLeft(byte* dest, ref int destIndex, int destLength, int align, int length)
		{
			if (align > 0)
			{
				while (length < align)
				{
					if (destIndex >= destLength)
					{
						return true;
					}
					dest[destIndex++] = 32;
					length++;
				}
			}
			return false;
		}

		private unsafe static int GetLengthForFormatGeneral(ref NumberBuffer number, int nMaxDigits)
		{
			int num = 0;
			int scale = number.Scale;
			int i = scale;
			bool flag = false;
			if (i > nMaxDigits || i < -3)
			{
				i = 1;
				flag = true;
			}
			byte* ptr = number.GetDigitsPointer();
			if (number.IsNegative)
			{
				num++;
			}
			if (i > 0)
			{
				do
				{
					if (*ptr != 0)
					{
						ptr++;
					}
					num++;
				}
				while (--i > 0);
			}
			else
			{
				num++;
			}
			if (*ptr != 0 || i < 0)
			{
				num++;
				for (; i < 0; i++)
				{
					num++;
				}
				for (; *ptr != 0; ptr++)
				{
					num++;
				}
			}
			if (flag)
			{
				num++;
				int num2 = number.Scale - 1;
				if (num2 >= 0)
				{
					num++;
				}
				num += GetLengthIntegerToString(num2, 10, 2);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe static void FormatGeneral(byte* dest, ref int destIndex, int destLength, ref NumberBuffer number, int nMaxDigits, byte expChar)
		{
			int scale = number.Scale;
			int i = scale;
			bool flag = false;
			if (i > nMaxDigits || i < -3)
			{
				i = 1;
				flag = true;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			if (number.IsNegative)
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 45;
			}
			if (i > 0)
			{
				do
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = (byte)((*digitsPointer != 0) ? (*(digitsPointer++)) : 48);
				}
				while (--i > 0);
			}
			else
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 48;
			}
			if (*digitsPointer != 0 || i < 0)
			{
				if (destIndex >= destLength)
				{
					return;
				}
				dest[destIndex++] = 46;
				for (; i < 0; i++)
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = 48;
				}
				while (*digitsPointer != 0)
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = *(digitsPointer++);
				}
			}
			if (flag && destIndex < destLength)
			{
				dest[destIndex++] = expChar;
				int num = number.Scale - 1;
				FormatOptions options = new FormatOptions(NumberFormatKind.DecimalForceSigned, 0, 2, lowercase: false);
				ConvertIntegerToString(dest, ref destIndex, destLength, num, options);
			}
		}

		private unsafe static void RoundNumber(ref NumberBuffer number, int pos, bool isCorrectlyRounded)
		{
			byte* digitsPointer = number.GetDigitsPointer();
			int i;
			for (i = 0; i < pos && digitsPointer[i] != 0; i++)
			{
			}
			if (i == pos && ShouldRoundUp(digitsPointer, i, isCorrectlyRounded))
			{
				while (i > 0 && digitsPointer[i - 1] == 57)
				{
					i--;
				}
				if (i > 0)
				{
					byte* num = digitsPointer + (i - 1);
					(*num)++;
				}
				else
				{
					number.Scale++;
					*digitsPointer = 49;
					i = 1;
				}
			}
			else
			{
				while (i > 0 && digitsPointer[i - 1] == 48)
				{
					i--;
				}
			}
			if (i == 0)
			{
				number.Scale = 0;
			}
			digitsPointer[i] = 0;
			number.DigitsCount = i;
		}

		private unsafe static bool ShouldRoundUp(byte* dig, int i, bool isCorrectlyRounded)
		{
			byte b = dig[i];
			if (b == 0 || isCorrectlyRounded)
			{
				return false;
			}
			return b >= 53;
		}

		private static uint LogBase2(uint val)
		{
			uint num = val >> 24;
			if (num != 0)
			{
				return (uint)(24 + logTable[num]);
			}
			num = val >> 16;
			if (num != 0)
			{
				return (uint)(16 + logTable[num]);
			}
			num = val >> 8;
			if (num != 0)
			{
				return (uint)(8 + logTable[num]);
			}
			return logTable[val];
		}

		private unsafe static int BigInt_Compare(in tBigInt lhs, in tBigInt rhs)
		{
			int num = lhs.m_length - rhs.m_length;
			if (num != 0)
			{
				return num;
			}
			for (int num2 = lhs.m_length - 1; num2 >= 0; num2--)
			{
				if (lhs.m_blocks[num2] != rhs.m_blocks[num2])
				{
					if (lhs.m_blocks[num2] > rhs.m_blocks[num2])
					{
						return 1;
					}
					return -1;
				}
			}
			return 0;
		}

		private static void BigInt_Add(out tBigInt pResult, in tBigInt lhs, in tBigInt rhs)
		{
			if (lhs.m_length < rhs.m_length)
			{
				BigInt_Add_internal(out pResult, in rhs, in lhs);
			}
			else
			{
				BigInt_Add_internal(out pResult, in lhs, in rhs);
			}
		}

		private unsafe static void BigInt_Add_internal(out tBigInt pResult, in tBigInt pLarge, in tBigInt pSmall)
		{
			int length = pLarge.m_length;
			int length2 = pSmall.m_length;
			pResult.m_length = length;
			ulong num = 0uL;
			fixed (uint* ptr = pLarge.m_blocks)
			{
				fixed (uint* ptr3 = pSmall.m_blocks)
				{
					fixed (uint* ptr5 = pResult.m_blocks)
					{
						uint* ptr2 = ptr;
						uint* ptr4 = ptr3;
						uint* ptr6 = ptr5;
						uint* ptr7 = ptr2 + length;
						uint* ptr8 = ptr4 + length2;
						while (ptr4 != ptr8)
						{
							ulong num2 = num + *ptr2 + *ptr4;
							num = num2 >> 32;
							*ptr6 = (uint)(num2 & 0xFFFFFFFFu);
							ptr2++;
							ptr4++;
							ptr6++;
						}
						while (ptr2 != ptr7)
						{
							ulong num3 = num + *ptr2;
							num = num3 >> 32;
							*ptr6 = (uint)(num3 & 0xFFFFFFFFu);
							ptr2++;
							ptr6++;
						}
						if (num != 0)
						{
							*ptr6 = 1u;
							pResult.m_length = length + 1;
						}
						else
						{
							pResult.m_length = length;
						}
					}
				}
			}
		}

		private static void BigInt_Multiply(out tBigInt pResult, in tBigInt lhs, in tBigInt rhs)
		{
			if (lhs.m_length < rhs.m_length)
			{
				BigInt_Multiply_internal(out pResult, in rhs, in lhs);
			}
			else
			{
				BigInt_Multiply_internal(out pResult, in lhs, in rhs);
			}
		}

		private unsafe static void BigInt_Multiply_internal(out tBigInt pResult, in tBigInt pLarge, in tBigInt pSmall)
		{
			int num = pLarge.m_length + pSmall.m_length;
			for (int i = 0; i < num; i++)
			{
				pResult.m_blocks[i] = 0u;
			}
			fixed (uint* ptr = pLarge.m_blocks)
			{
				uint* ptr2 = ptr;
				uint* ptr3 = ptr2 + pLarge.m_length;
				fixed (uint* ptr7 = pResult.m_blocks)
				{
					fixed (uint* ptr4 = pSmall.m_blocks)
					{
						uint* ptr5 = ptr4;
						uint* ptr6 = ptr5 + pSmall.m_length;
						uint* ptr8 = ptr7;
						while (ptr5 != ptr6)
						{
							uint num2 = *ptr5;
							if (num2 != 0)
							{
								uint* ptr9 = ptr2;
								uint* ptr10 = ptr8;
								ulong num3 = 0uL;
								do
								{
									ulong num4 = (ulong)(*ptr10 + (long)(*ptr9) * (long)num2) + num3;
									num3 = num4 >> 32;
									*ptr10 = (uint)(num4 & 0xFFFFFFFFu);
									ptr9++;
									ptr10++;
								}
								while (ptr9 != ptr3);
								*ptr10 = (uint)(num3 & 0xFFFFFFFFu);
							}
							ptr5++;
							ptr8++;
						}
						if (num > 0 && pResult.m_blocks[num - 1] == 0)
						{
							pResult.m_length = num - 1;
						}
						else
						{
							pResult.m_length = num;
						}
					}
				}
			}
		}

		private unsafe static void BigInt_Multiply(out tBigInt pResult, in tBigInt lhs, uint rhs)
		{
			uint num = 0u;
			fixed (uint* ptr = pResult.m_blocks)
			{
				fixed (uint* ptr3 = lhs.m_blocks)
				{
					uint* ptr2 = ptr;
					uint* ptr4 = ptr3;
					uint* ptr5 = ptr4 + lhs.m_length;
					while (ptr4 != ptr5)
					{
						ulong num2 = (ulong)((long)(*ptr4) * (long)rhs + num);
						*ptr2 = (uint)(num2 & 0xFFFFFFFFu);
						num = (uint)(num2 >> 32);
						ptr4++;
						ptr2++;
					}
					if (num != 0)
					{
						*ptr2 = num;
						pResult.m_length = lhs.m_length + 1;
					}
					else
					{
						pResult.m_length = lhs.m_length;
					}
				}
			}
		}

		private unsafe static void BigInt_Multiply2(out tBigInt pResult, in tBigInt input)
		{
			uint num = 0u;
			fixed (uint* ptr = pResult.m_blocks)
			{
				fixed (uint* ptr3 = input.m_blocks)
				{
					uint* ptr2 = ptr;
					uint* ptr4 = ptr3;
					uint* ptr5 = ptr4 + input.m_length;
					while (ptr4 != ptr5)
					{
						uint num2 = *ptr4;
						*ptr2 = (num2 << 1) | num;
						num = num2 >> 31;
						ptr4++;
						ptr2++;
					}
					if (num != 0)
					{
						*ptr2 = num;
						pResult.m_length = input.m_length + 1;
					}
					else
					{
						pResult.m_length = input.m_length;
					}
				}
			}
		}

		private unsafe static void BigInt_Multiply2(ref tBigInt pResult)
		{
			uint num = 0u;
			fixed (uint* ptr = pResult.m_blocks)
			{
				uint* ptr2 = ptr;
				for (uint* ptr3 = ptr2 + pResult.m_length; ptr2 != ptr3; ptr2++)
				{
					uint num2 = *ptr2;
					*ptr2 = (num2 << 1) | num;
					num = num2 >> 31;
				}
				if (num != 0)
				{
					*ptr2 = num;
					pResult.m_length++;
				}
			}
		}

		private unsafe static void BigInt_Multiply10(ref tBigInt pResult)
		{
			ulong num = 0uL;
			fixed (uint* ptr = pResult.m_blocks)
			{
				uint* ptr2 = ptr;
				for (uint* ptr3 = ptr2 + pResult.m_length; ptr2 != ptr3; ptr2++)
				{
					ulong num2 = (ulong)((long)(*ptr2) * 10L) + num;
					*ptr2 = (uint)(num2 & 0xFFFFFFFFu);
					num = num2 >> 32;
				}
				if (num != 0)
				{
					*ptr2 = (uint)num;
					pResult.m_length++;
				}
			}
		}

		private unsafe static tBigInt g_PowerOf10_Big(int i)
		{
			tBigInt result = default(tBigInt);
			switch (i)
			{
			case 0:
				result.m_length = 1;
				result.m_blocks[0] = 100000000u;
				break;
			case 1:
				result.m_length = 2;
				result.m_blocks[0] = 1874919424u;
				result.m_blocks[1] = 2328306u;
				break;
			case 2:
				result.m_length = 4;
				result.m_blocks[0] = 0u;
				result.m_blocks[1] = 2242703233u;
				result.m_blocks[2] = 762134875u;
				result.m_blocks[3] = 1262u;
				break;
			case 3:
				result.m_length = 7;
				result.m_blocks[0] = 0u;
				result.m_blocks[1] = 0u;
				result.m_blocks[2] = 3211403009u;
				result.m_blocks[3] = 1849224548u;
				result.m_blocks[4] = 3668416493u;
				result.m_blocks[5] = 3913284084u;
				result.m_blocks[6] = 1593091u;
				break;
			case 4:
				result.m_length = 14;
				result.m_blocks[0] = 0u;
				result.m_blocks[1] = 0u;
				result.m_blocks[2] = 0u;
				result.m_blocks[3] = 0u;
				result.m_blocks[4] = 781532673u;
				result.m_blocks[5] = 64985353u;
				result.m_blocks[6] = 253049085u;
				result.m_blocks[7] = 594863151u;
				result.m_blocks[8] = 3553621484u;
				result.m_blocks[9] = 3288652808u;
				result.m_blocks[10] = 3167596762u;
				result.m_blocks[11] = 2788392729u;
				result.m_blocks[12] = 3911132675u;
				result.m_blocks[13] = 590u;
				break;
			default:
				result.m_length = 27;
				result.m_blocks[0] = 0u;
				result.m_blocks[1] = 0u;
				result.m_blocks[2] = 0u;
				result.m_blocks[3] = 0u;
				result.m_blocks[4] = 0u;
				result.m_blocks[5] = 0u;
				result.m_blocks[6] = 0u;
				result.m_blocks[7] = 0u;
				result.m_blocks[8] = 2553183233u;
				result.m_blocks[9] = 3201533787u;
				result.m_blocks[10] = 3638140786u;
				result.m_blocks[11] = 303378311u;
				result.m_blocks[12] = 1809731782u;
				result.m_blocks[13] = 3477761648u;
				result.m_blocks[14] = 3583367183u;
				result.m_blocks[15] = 649228654u;
				result.m_blocks[16] = 2915460784u;
				result.m_blocks[17] = 487929380u;
				result.m_blocks[18] = 1011012442u;
				result.m_blocks[19] = 1677677582u;
				result.m_blocks[20] = 3428152256u;
				result.m_blocks[21] = 1710878487u;
				result.m_blocks[22] = 1438394610u;
				result.m_blocks[23] = 2161952759u;
				result.m_blocks[24] = 4100910556u;
				result.m_blocks[25] = 1608314830u;
				result.m_blocks[26] = 349175u;
				break;
			}
			return result;
		}

		private static void BigInt_Pow10(out tBigInt pResult, uint exponent)
		{
			tBigInt lhs = default(tBigInt);
			tBigInt pResult2 = default(tBigInt);
			uint num = exponent & 7u;
			lhs.SetU32(g_PowerOf10_U32[num]);
			exponent >>= 3;
			int num2 = 0;
			while (exponent != 0)
			{
				if ((exponent & (true ? 1u : 0u)) != 0)
				{
					tBigInt rhs = g_PowerOf10_Big(num2);
					BigInt_Multiply(out pResult2, in lhs, in rhs);
					lhs = pResult2;
					pResult2 = lhs;
				}
				num2++;
				exponent >>= 1;
			}
			pResult = lhs;
		}

		private static void BigInt_MultiplyPow10(out tBigInt pResult, in tBigInt input, uint exponent)
		{
			tBigInt pResult2 = default(tBigInt);
			tBigInt pResult3 = default(tBigInt);
			uint num = exponent & 7u;
			if (num != 0)
			{
				BigInt_Multiply(out pResult2, in input, g_PowerOf10_U32[num]);
			}
			else
			{
				pResult2 = input;
			}
			exponent >>= 3;
			int num2 = 0;
			while (exponent != 0)
			{
				if ((exponent & (true ? 1u : 0u)) != 0)
				{
					tBigInt rhs = g_PowerOf10_Big(num2);
					BigInt_Multiply(out pResult3, in pResult2, in rhs);
					pResult2 = pResult3;
					pResult3 = pResult2;
				}
				num2++;
				exponent >>= 1;
			}
			pResult = pResult2;
		}

		private unsafe static void BigInt_Pow2(out tBigInt pResult, uint exponent)
		{
			int num = (int)exponent / 32;
			for (uint num2 = 0u; num2 <= num; num2++)
			{
				pResult.m_blocks[num2] = 0u;
			}
			pResult.m_length = num + 1;
			int num3 = (int)exponent % 32;
			ref uint reference = ref pResult.m_blocks[num];
			reference |= (uint)(1 << num3);
		}

		private unsafe static uint BigInt_DivideWithRemainder_MaxQuotient9(ref tBigInt pDividend, in tBigInt divisor)
		{
			int num = divisor.m_length;
			if (pDividend.m_length < divisor.m_length)
			{
				return 0u;
			}
			fixed (uint* ptr = divisor.m_blocks)
			{
				fixed (uint* ptr3 = pDividend.m_blocks)
				{
					uint* ptr2 = ptr;
					uint* ptr4 = ptr3;
					uint* ptr5 = ptr2 + num - 1;
					uint* ptr6 = ptr4 + num - 1;
					uint num2 = *ptr6 / (*ptr5 + 1);
					if (num2 != 0)
					{
						ulong num3 = 0uL;
						ulong num4 = 0uL;
						do
						{
							ulong num5 = (ulong)((long)(*ptr2) * (long)num2) + num4;
							num4 = num5 >> 32;
							ulong num6 = *ptr4 - (num5 & 0xFFFFFFFFu) - num3;
							num3 = (num6 >> 32) & 1;
							*ptr4 = (uint)(num6 & 0xFFFFFFFFu);
							ptr2++;
							ptr4++;
						}
						while (ptr2 <= ptr5);
						while (num > 0 && pDividend.m_blocks[num - 1] == 0)
						{
							num--;
						}
						pDividend.m_length = num;
					}
					if (BigInt_Compare(in pDividend, in divisor) >= 0)
					{
						num2++;
						ptr2 = ptr;
						ptr4 = ptr3;
						ulong num7 = 0uL;
						do
						{
							ulong num8 = (ulong)((long)(*ptr4) - (long)(*ptr2)) - num7;
							num7 = (num8 >> 32) & 1;
							*ptr4 = (uint)(num8 & 0xFFFFFFFFu);
							ptr2++;
							ptr4++;
						}
						while (ptr2 <= ptr5);
						while (num > 0 && pDividend.m_blocks[num - 1] == 0)
						{
							num--;
						}
						pDividend.m_length = num;
					}
					return num2;
				}
			}
		}

		private unsafe static void BigInt_ShiftLeft(ref tBigInt pResult, uint shift)
		{
			int num = (int)shift / 32;
			int num2 = (int)shift % 32;
			int length = pResult.m_length;
			if (num2 == 0)
			{
				fixed (uint* ptr = pResult.m_blocks)
				{
					uint* ptr2 = ptr;
					uint* ptr3 = ptr2 + length - 1;
					uint* ptr4 = ptr3 + num;
					while (ptr3 >= ptr2)
					{
						*ptr4 = *ptr3;
						ptr3--;
						ptr4--;
					}
				}
				for (uint num3 = 0u; num3 < num; num3++)
				{
					pResult.m_blocks[num3] = 0u;
				}
				pResult.m_length += num;
				return;
			}
			int num4 = length - 1;
			int num5 = length + num;
			pResult.m_length = num5 + 1;
			int num6 = 32 - num2;
			uint num7 = 0u;
			uint num8 = pResult.m_blocks[num4];
			uint num9 = num8 >> num6;
			while (num4 > 0)
			{
				pResult.m_blocks[num5] = num7 | num9;
				num7 = num8 << num2;
				num4--;
				num5--;
				num8 = pResult.m_blocks[num4];
				num9 = num8 >> num6;
			}
			pResult.m_blocks[num5] = num7 | num9;
			pResult.m_blocks[num5 - 1] = num8 << num2;
			for (uint num10 = 0u; num10 < num; num10++)
			{
				pResult.m_blocks[num10] = 0u;
			}
			if (pResult.m_blocks[pResult.m_length - 1] == 0)
			{
				pResult.m_length--;
			}
		}

		private unsafe static uint Dragon4(ulong mantissa, int exponent, uint mantissaHighBitIdx, bool hasUnequalMargins, CutoffMode cutoffMode, uint cutoffNumber, byte* pOutBuffer, uint bufferSize, out int pOutExponent)
		{
			byte* ptr = pOutBuffer;
			if (mantissa == 0)
			{
				*ptr = 48;
				pOutExponent = 0;
				return 1u;
			}
			tBigInt pResult = default(tBigInt);
			tBigInt pResult2 = default(tBigInt);
			tBigInt pResult3 = default(tBigInt);
			tBigInt pResult4 = default(tBigInt);
			tBigInt* ptr2;
			if (hasUnequalMargins)
			{
				if (exponent > 0)
				{
					pResult2.SetU64(4 * mantissa);
					BigInt_ShiftLeft(ref pResult2, (uint)exponent);
					pResult.SetU32(4u);
					BigInt_Pow2(out pResult3, (uint)exponent);
					BigInt_Pow2(out pResult4, (uint)(exponent + 1));
				}
				else
				{
					pResult2.SetU64(4 * mantissa);
					BigInt_Pow2(out pResult, (uint)(-exponent + 2));
					pResult3.SetU32(1u);
					pResult4.SetU32(2u);
				}
				ptr2 = &pResult4;
			}
			else
			{
				if (exponent > 0)
				{
					pResult2.SetU64(2 * mantissa);
					BigInt_ShiftLeft(ref pResult2, (uint)exponent);
					pResult.SetU32(2u);
					BigInt_Pow2(out pResult3, (uint)exponent);
				}
				else
				{
					pResult2.SetU64(2 * mantissa);
					BigInt_Pow2(out pResult, (uint)(-exponent + 1));
					pResult3.SetU32(1u);
				}
				ptr2 = &pResult3;
			}
			double a = (double)((int)mantissaHighBitIdx + exponent) * 0.3010299956639812 - 0.69;
			a = Math.Ceiling(a);
			int num = (int)a;
			if (cutoffMode == CutoffMode.FractionLength && num <= (int)(0 - cutoffNumber))
			{
				num = (int)(0 - cutoffNumber + 1);
			}
			if (num > 0)
			{
				BigInt_MultiplyPow10(out var pResult5, in pResult, (uint)num);
				pResult = pResult5;
			}
			else if (num < 0)
			{
				BigInt_Pow10(out var pResult6, (uint)(-num));
				BigInt_Multiply(out var pResult7, in pResult2, in pResult6);
				pResult2 = pResult7;
				BigInt_Multiply(out pResult7, in pResult3, in pResult6);
				pResult3 = pResult7;
				if (ptr2 != &pResult3)
				{
					BigInt_Multiply2(out *ptr2, in pResult3);
				}
			}
			if (BigInt_Compare(in pResult2, in pResult) >= 0)
			{
				num++;
			}
			else
			{
				BigInt_Multiply10(ref pResult2);
				BigInt_Multiply10(ref pResult3);
				if (ptr2 != &pResult3)
				{
					BigInt_Multiply2(out *ptr2, in pResult3);
				}
			}
			int num2 = num - (int)bufferSize;
			switch (cutoffMode)
			{
			case CutoffMode.TotalLength:
			{
				int num4 = num - (int)cutoffNumber;
				if (num4 > num2)
				{
					num2 = num4;
				}
				break;
			}
			case CutoffMode.FractionLength:
			{
				int num3 = (int)(0 - cutoffNumber);
				if (num3 > num2)
				{
					num2 = num3;
				}
				break;
			}
			}
			pOutExponent = num - 1;
			uint block = pResult.GetBlock(pResult.GetLength() - 1);
			if (block < 8 || block > 429496729)
			{
				uint num5 = LogBase2(block);
				uint shift = (59 - num5) % 32;
				BigInt_ShiftLeft(ref pResult, shift);
				BigInt_ShiftLeft(ref pResult2, shift);
				BigInt_ShiftLeft(ref pResult3, shift);
				if (ptr2 != &pResult3)
				{
					BigInt_Multiply2(out *ptr2, in pResult3);
				}
			}
			uint num6;
			bool flag;
			bool flag2;
			if (cutoffMode == CutoffMode.Unique)
			{
				while (true)
				{
					num--;
					num6 = BigInt_DivideWithRemainder_MaxQuotient9(ref pResult2, in pResult);
					BigInt_Add(out var pResult8, in pResult2, in *ptr2);
					flag = BigInt_Compare(in pResult2, in pResult3) < 0;
					flag2 = BigInt_Compare(in pResult8, in pResult) > 0;
					if (flag || flag2 || num == num2)
					{
						break;
					}
					*ptr = (byte)(48 + num6);
					ptr++;
					BigInt_Multiply10(ref pResult2);
					BigInt_Multiply10(ref pResult3);
					if (ptr2 != &pResult3)
					{
						BigInt_Multiply2(out *ptr2, in pResult3);
					}
				}
			}
			else
			{
				flag = false;
				flag2 = false;
				while (true)
				{
					num--;
					num6 = BigInt_DivideWithRemainder_MaxQuotient9(ref pResult2, in pResult);
					if (pResult2.IsZero() || num == num2)
					{
						break;
					}
					*ptr = (byte)(48 + num6);
					ptr++;
					BigInt_Multiply10(ref pResult2);
				}
			}
			bool flag3 = flag;
			if (flag == flag2)
			{
				BigInt_Multiply2(ref pResult2);
				int num7 = BigInt_Compare(in pResult2, in pResult);
				flag3 = num7 < 0;
				if (num7 == 0)
				{
					flag3 = (num6 & 1) == 0;
				}
			}
			if (flag3)
			{
				*ptr = (byte)(48 + num6);
				ptr++;
			}
			else if (num6 == 9)
			{
				while (true)
				{
					if (ptr == pOutBuffer)
					{
						*ptr = 49;
						ptr++;
						pOutExponent++;
						break;
					}
					ptr--;
					if (*ptr != 57)
					{
						byte* intPtr = ptr;
						(*intPtr)++;
						ptr++;
						break;
					}
				}
			}
			else
			{
				*ptr = (byte)(48 + num6 + 1);
				ptr++;
			}
			return (uint)(ptr - pOutBuffer);
		}

		private unsafe static int FormatPositional(byte* pOutBuffer, uint bufferSize, ulong mantissa, int exponent, uint mantissaHighBitIdx, bool hasUnequalMargins, int precision)
		{
			uint num = bufferSize - 1;
			int pOutExponent;
			uint num2 = ((precision >= 0) ? Dragon4(mantissa, exponent, mantissaHighBitIdx, hasUnequalMargins, CutoffMode.FractionLength, (uint)precision, pOutBuffer, num, out pOutExponent) : Dragon4(mantissa, exponent, mantissaHighBitIdx, hasUnequalMargins, CutoffMode.Unique, 0u, pOutBuffer, num, out pOutExponent));
			uint num3 = 0u;
			if (pOutExponent >= 0)
			{
				uint num4 = (uint)(pOutExponent + 1);
				if (num2 < num4)
				{
					if (num4 > num)
					{
						num4 = num;
					}
					for (; num2 < num4; num2++)
					{
						pOutBuffer[num2] = 48;
					}
				}
				else if (num2 > num4)
				{
					num3 = num2 - num4;
					uint num5 = num - num4 - 1;
					if (num3 > num5)
					{
						num3 = num5;
					}
					Unsafe.CopyBlock((void*)(pOutBuffer + num4 + 1), (void*)(pOutBuffer + num4), num3);
					pOutBuffer[num4] = 46;
					num2 = num4 + 1 + num3;
				}
			}
			else
			{
				if (num > 2)
				{
					uint num6 = (uint)(-pOutExponent - 1);
					uint num7 = num - 2;
					if (num6 > num7)
					{
						num6 = num7;
					}
					uint num8 = 2 + num6;
					num3 = num2;
					uint num9 = num - num8;
					if (num3 > num9)
					{
						num3 = num9;
					}
					Unsafe.CopyBlock((void*)(pOutBuffer + num8), (void*)pOutBuffer, num3);
					for (uint num10 = 2u; num10 < num8; num10++)
					{
						pOutBuffer[num10] = 48;
					}
					num3 += num6;
					num2 = num3;
				}
				if (num > 1)
				{
					pOutBuffer[1] = 46;
					num2++;
				}
				if (num != 0)
				{
					*pOutBuffer = 48;
					num2++;
				}
			}
			if (precision > (int)num3 && num2 < num)
			{
				if (num3 == 0)
				{
					pOutBuffer[num2++] = 46;
				}
				uint num11 = (uint)(num2 + (precision - (int)num3));
				if (num11 > num)
				{
					num11 = num;
				}
				for (; num2 < num11; num2++)
				{
					pOutBuffer[num2] = 48;
				}
			}
			return (int)num2;
		}

		private unsafe static int FormatScientific(byte* pOutBuffer, uint bufferSize, ulong mantissa, int exponent, uint mantissaHighBitIdx, bool hasUnequalMargins, int precision)
		{
			int pOutExponent;
			uint num = ((precision >= 0) ? Dragon4(mantissa, exponent, mantissaHighBitIdx, hasUnequalMargins, CutoffMode.TotalLength, (uint)(precision + 1), pOutBuffer, bufferSize, out pOutExponent) : Dragon4(mantissa, exponent, mantissaHighBitIdx, hasUnequalMargins, CutoffMode.Unique, 0u, pOutBuffer, bufferSize, out pOutExponent));
			byte* ptr = pOutBuffer;
			if (bufferSize > 1)
			{
				ptr++;
				bufferSize--;
			}
			uint num2 = num - 1;
			if (num2 != 0 && bufferSize > 1)
			{
				uint num3 = bufferSize - 2;
				if (num2 > num3)
				{
					num2 = num3;
				}
				Unsafe.CopyBlock((void*)(ptr + 1), (void*)ptr, num2);
				*ptr = 46;
				ptr += 1 + num2;
				bufferSize -= 1 + num2;
			}
			if (precision > (int)num2 && bufferSize > 1)
			{
				if (num2 == 0)
				{
					*ptr = 46;
					ptr++;
					bufferSize--;
				}
				uint num4 = (uint)(precision - num2);
				if (num4 > bufferSize - 1)
				{
					num4 = bufferSize - 1;
				}
				for (byte* ptr2 = ptr + num4; ptr < ptr2; ptr++)
				{
					*ptr = 48;
				}
			}
			if (bufferSize > 1)
			{
				byte* ptr3 = stackalloc byte[5];
				*ptr3 = 101;
				if (pOutExponent >= 0)
				{
					ptr3[1] = 43;
				}
				else
				{
					ptr3[1] = 45;
					pOutExponent = -pOutExponent;
				}
				uint num5 = (uint)(pOutExponent / 100);
				uint num6 = (uint)((pOutExponent - num5 * 100) / 10);
				uint num7 = (uint)(pOutExponent - num5 * 100 - num6 * 10);
				ptr3[2] = (byte)(48 + num5);
				ptr3[3] = (byte)(48 + num6);
				ptr3[4] = (byte)(48 + num7);
				uint num8 = bufferSize - 1;
				uint num9 = ((5 < num8) ? 5u : num8);
				Unsafe.CopyBlock((void*)ptr, (void*)ptr3, num9);
				ptr += num9;
				bufferSize -= num9;
			}
			return (int)(ptr - pOutBuffer);
		}

		private unsafe static void FormatInfinityNaN(byte* dest, ref int destIndex, int destLength, ulong mantissa, bool isNegative, FormatOptions formatOptions)
		{
			int length = ((mantissa == 0L) ? (8 + (isNegative ? 1 : 0)) : 3);
			int alignAndSize = formatOptions.AlignAndSize;
			if (AlignLeft(dest, ref destIndex, destLength, alignAndSize, length))
			{
				return;
			}
			if (mantissa == 0)
			{
				if (isNegative)
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = 45;
				}
				for (int i = 0; i < 8; i++)
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = InfinityString[i];
				}
			}
			else
			{
				for (int j = 0; j < 3; j++)
				{
					if (destIndex >= destLength)
					{
						return;
					}
					dest[destIndex++] = NanString[j];
				}
			}
			AlignRight(dest, ref destIndex, destLength, alignAndSize, length);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe static void ConvertFloatToString(byte* dest, ref int destIndex, int destLength, float value, FormatOptions formatOptions)
		{
			tFloatUnion32 tFloatUnion = default(tFloatUnion32);
			tFloatUnion.m_floatingPoint = value;
			uint exponent = tFloatUnion.GetExponent();
			uint mantissa = tFloatUnion.GetMantissa();
			uint num;
			int exponent2;
			uint mantissaHighBitIdx;
			bool hasUnequalMargins;
			switch (exponent)
			{
			case 255u:
				FormatInfinityNaN(dest, ref destIndex, destLength, mantissa, tFloatUnion.IsNegative(), formatOptions);
				return;
			default:
				num = (uint)(0x800000uL | (ulong)mantissa);
				exponent2 = (int)(exponent - 127 - 23);
				mantissaHighBitIdx = 23u;
				hasUnequalMargins = exponent != 1 && mantissa == 0;
				break;
			case 0u:
				num = mantissa;
				exponent2 = -149;
				mantissaHighBitIdx = LogBase2(num);
				hasUnequalMargins = false;
				break;
			}
			int num2 = ((formatOptions.Specifier == 0) ? (-1) : formatOptions.Specifier);
			int num3 = Math.Max(10, num2 + 1);
			byte* ptr = stackalloc byte[(int)(uint)num3];
			if (num2 < 0)
			{
				num2 = 7;
			}
			int pOutExponent;
			uint num4 = Dragon4(num, exponent2, mantissaHighBitIdx, hasUnequalMargins, CutoffMode.TotalLength, (uint)num2, ptr, (uint)(num3 - 1), out pOutExponent);
			ptr[num4] = 0;
			bool isNegative = tFloatUnion.IsNegative();
			if (tFloatUnion.m_integer == 2147483648u)
			{
				isNegative = false;
			}
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Float, ptr, (int)num4, pOutExponent + 1, isNegative);
			FormatNumber(dest, ref destIndex, destLength, ref number, num2, formatOptions);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private unsafe static void ConvertDoubleToString(byte* dest, ref int destIndex, int destLength, double value, FormatOptions formatOptions)
		{
			tFloatUnion64 tFloatUnion = default(tFloatUnion64);
			tFloatUnion.m_floatingPoint = value;
			uint exponent = tFloatUnion.GetExponent();
			ulong mantissa = tFloatUnion.GetMantissa();
			ulong num;
			int exponent2;
			uint mantissaHighBitIdx;
			bool hasUnequalMargins;
			switch (exponent)
			{
			case 2047u:
				FormatInfinityNaN(dest, ref destIndex, destLength, mantissa, tFloatUnion.IsNegative(), formatOptions);
				return;
			default:
				num = 0x10000000000000uL | mantissa;
				exponent2 = (int)(exponent - 1023 - 52);
				mantissaHighBitIdx = 52u;
				hasUnequalMargins = exponent != 1 && mantissa == 0;
				break;
			case 0u:
				num = mantissa;
				exponent2 = -1074;
				mantissaHighBitIdx = LogBase2((uint)num);
				hasUnequalMargins = false;
				break;
			}
			int num2 = ((formatOptions.Specifier == 0) ? (-1) : formatOptions.Specifier);
			int num3 = Math.Max(18, num2 + 1);
			byte* ptr = stackalloc byte[(int)(uint)num3];
			if (num2 < 0)
			{
				num2 = 15;
			}
			int pOutExponent;
			uint num4 = Dragon4(num, exponent2, mantissaHighBitIdx, hasUnequalMargins, CutoffMode.TotalLength, (uint)num2, ptr, (uint)(num3 - 1), out pOutExponent);
			ptr[num4] = 0;
			bool isNegative = tFloatUnion.IsNegative();
			if (tFloatUnion.m_integer == 9223372036854775808uL)
			{
				isNegative = false;
			}
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Float, ptr, (int)num4, pOutExponent + 1, isNegative);
			FormatNumber(dest, ref destIndex, destLength, ref number, num2, formatOptions);
		}
	}
	internal enum DiagnosticId
	{
		ERR_InternalCompilerErrorInBackend = 100,
		ERR_InternalCompilerErrorInFunction = 101,
		ERR_InternalCompilerErrorInInstruction = 102,
		ERR_OnlyStaticMethodsAllowed = 1000,
		ERR_UnableToAccessManagedMethod = 1001,
		ERR_UnableToFindInterfaceMethod = 1002,
		ERR_UnexpectedEmptyMethodBody = 1003,
		ERR_ManagedArgumentsNotSupported = 1004,
		ERR_CatchConstructionNotSupported = 1006,
		ERR_CatchAndFilterConstructionNotSupported = 1007,
		ERR_LdfldaWithFixedArrayExpected = 1008,
		ERR_PointerExpected = 1009,
		ERR_LoadingFieldFromManagedObjectNotSupported = 1010,
		ERR_LoadingFieldWithManagedTypeNotSupported = 1011,
		ERR_LoadingArgumentWithManagedTypeNotSupported = 1012,
		ERR_CallingBurstDiscardMethodWithReturnValueNotSupported = 1015,
		ERR_CallingManagedMethodNotSupported = 1016,
		ERR_InstructionUnboxNotSupported = 1019,
		ERR_InstructionBoxNotSupported = 1020,
		ERR_InstructionNewobjWithManagedTypeNotSupported = 1021,
		ERR_AccessingManagedArrayNotSupported = 1022,
		ERR_InstructionLdtokenFieldNotSupported = 1023,
		ERR_InstructionLdtokenMethodNotSupported = 1024,
		ERR_InstructionLdtokenTypeNotSupported = 1025,
		ERR_InstructionLdtokenNotSupported = 1026,
		ERR_InstructionLdvirtftnNotSupported = 1027,
		ERR_InstructionNewarrNotSupported = 1028,
		ERR_InstructionRethrowNotSupported = 1029,
		ERR_InstructionCastclassNotSupported = 1030,
		ERR_InstructionLdftnNotSupported = 1032,
		ERR_InstructionLdstrNotSupported = 1033,
		ERR_InstructionStsfldNotSupported = 1034,
		ERR_InstructionEndfilterNotSupported = 1035,
		ERR_InstructionEndfinallyNotSupported = 1036,
		ERR_InstructionLeaveNotSupported = 1037,
		ERR_InstructionNotSupported = 1038,
		ERR_LoadingFromStaticFieldNotSupported = 1039,
		ERR_LoadingFromNonReadonlyStaticFieldNotSupported = 1040,
		ERR_LoadingFromManagedStaticFieldNotSupported = 1041,
		ERR_LoadingFromManagedNonReadonlyStaticFieldNotSupported = 1042,
		ERR_InstructionStfldToManagedObjectNotSupported = 1043,
		ERR_InstructionLdlenNonConstantLengthNotSupported = 1044,
		ERR_StructWithAutoLayoutNotSupported = 1045,
		ERR_StructWithGenericParametersAndExplicitLayoutNotSupported = 1047,
		ERR_StructSizeNotSupported = 1048,
		ERR_StructZeroSizeNotSupported = 1049,
		ERR_MarshalAsOnFieldNotSupported = 1050,
		ERR_TypeNotSupported = 1051,
		ERR_RequiredTypeModifierNotSupported = 1052,
		ERR_ErrorWhileProcessingVariable = 1053,
		ERR_UnableToResolveType = 1054,
		ERR_UnableToResolveMethod = 1055,
		ERR_ConstructorNotSupported = 1056,
		ERR_FunctionPointerMethodMissingBurstCompileAttribute = 1057,
		ERR_FunctionPointerTypeMissingBurstCompileAttribute = 1058,
		ERR_FunctionPointerMethodAndTypeMissingBurstCompileAttribute = 1059,
		INF_FunctionPointerMethodAndTypeMissingMonoPInvokeCallbackAttribute = 10590,
		ERR_MarshalAsOnParameterNotSupported = 1061,
		ERR_MarshalAsOnReturnTypeNotSupported = 1062,
		ERR_TypeNotBlittableForFunctionPointer = 1063,
		ERR_StructByValueNotSupported = 1064,
		ERR_StructsWithNonUnicodeCharsNotSupported = 1066,
		ERR_VectorsByValueNotSupported = 1067,
		ERR_MissingExternBindings = 1068,
		ERR_MarshalAsNativeTypeOnReturnTypeNotSupported = 1069,
		ERR_AssertTypeNotSupported = 1071,
		ERR_StoringToReadOnlyFieldNotAllowed = 1072,
		ERR_StoringToFieldInReadOnlyParameterNotAllowed = 1073,
		ERR_StoringToReadOnlyParameterNotAllowed = 1074,
		ERR_TypeManagerStaticFieldNotCompatible = 1075,
		ERR_UnableToFindTypeIndexForTypeManagerType = 1076,
		ERR_UnableToFindFieldForTypeManager = 1077,
		ERR_CircularStaticConstructorUsage = 1090,
		ERR_ExternalInternalCallsInStaticConstructorsNotSupported = 1091,
		ERR_PlatformNotSupported = 1092,
		ERR_InitModuleVerificationError = 1093,
		ERR_ModuleVerificationError = 1094,
		ERR_UnableToFindTypeRequiredForTypeManager = 1095,
		ERR_UnexpectedIntegerTypesForBinaryOperation = 1096,
		ERR_BinaryOperationNotSupported = 1097,
		ERR_CalliWithThisNotSupported = 1098,
		ERR_CalliNonCCallingConventionNotSupported = 1099,
		ERR_StringLiteralTooBig = 1100,
		ERR_LdftnNonCCallingConventionNotSupported = 1101,
		ERR_UnableToCallMethodOnInterfaceObject = 1102,
		ERR_UnsupportedCpuDependentBranch = 1199,
		ERR_InstructionTargetCpuFeatureNotAllowedInThisBlock = 1200,
		ERR_AssumeRangeTypeMustBeInteger = 1201,
		ERR_AssumeRangeTypeMustBeSameSign = 1202,
		ERR_UnsupportedSpillTransform = 1300,
		ERR_UnsupportedSpillTransformTooManyUsers = 1301,
		ERR_MethodNotSupported = 1302,
		ERR_VectorsLoadFieldIsAddress = 1303,
		ERR_ConstantExpressionRequired = 1304,
		ERR_PointerArgumentsUnexpectedAliasing = 1310,
		ERR_LoopIntrinsicMustBeCalledInsideLoop = 1320,
		ERR_LoopUnexpectedAutoVectorization = 1321,
		WRN_LoopIntrinsicCalledButLoopOptimizedAway = 1322,
		ERR_AssertArgTypesDiffer = 1330,
		ERR_StringInternalCompilerFixedStringTooManyUsers = 1340,
		ERR_StringInvalidFormatMissingClosingBrace = 1341,
		ERR_StringInvalidIntegerForArgumentIndex = 1342,
		ERR_StringInvalidFormatForArgument = 1343,
		ERR_StringArgumentIndexOutOfRange = 1344,
		ERR_StringInvalidArgumentType = 1345,
		ERR_DebugLogNotSupported = 1346,
		ERR_StringInvalidNonLiteralFormat = 1347,
		ERR_StringInvalidStringFormatMethod = 1348,
		ERR_StringInvalidArgument = 1349,
		ERR_StringArrayInvalidArrayCreation = 1350,
		ERR_StringArrayInvalidArraySize = 1351,
		ERR_StringArrayInvalidControlFlow = 1352,
		ERR_StringArrayInvalidArrayIndex = 1353,
		ERR_StringArrayInvalidArrayIndexOutOfRange = 1354,
		ERR_UnmanagedStringMethodMissing = 1355,
		ERR_UnmanagedStringMethodInvalid = 1356,
		ERR_ManagedStaticConstructor = 1360,
		ERR_StaticConstantArrayInStaticConstructor = 1361,
		WRN_ExceptionThrownInNonSafetyCheckGuardedFunction = 1370,
		WRN_ACallToMethodHasBeenDiscarded = 1371,
		ERR_AccessingNestedManagedArrayNotSupported = 1380,
		ERR_LdobjFromANonPointerNonReference = 1381,
		ERR_StringLiteralRequired = 1382,
		ERR_MultiDimensionalArrayUnsupported = 1383,
		ERR_NonBlittableAndNonManagedSequentialStructNotSupported = 1384,
		ERR_VarArgFunctionNotSupported = 1385
	}
	public interface IFunctionPointer
	{
		[Obsolete("This method will be removed in a future version of Burst")]
		IFunctionPointer FromIntPtr(IntPtr ptr);
	}
	public readonly struct FunctionPointer<T> : IFunctionPointer
	{
		[NativeDisableUnsafePtrRestriction]
		private readonly IntPtr _ptr;

		public IntPtr Value => _ptr;

		public T Invoke => Marshal.GetDelegateForFunctionPointer<T>(_ptr);

		public bool IsCreated => _ptr != IntPtr.Zero;

		public FunctionPointer(IntPtr ptr)
		{
			_ptr = ptr;
		}

		[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
		private void CheckIsCreated()
		{
			if (!IsCreated)
			{
				throw new NullReferenceException("Object reference not set to an instance of an object");
			}
		}

		IFunctionPointer IFunctionPointer.FromIntPtr(IntPtr ptr)
		{
			return new FunctionPointer<T>(ptr);
		}
	}
	[AttributeUsage(AttributeTargets.Struct | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue)]
	public class NoAliasAttribute : Attribute
	{
	}
	internal static class SafeStringArrayHelper
	{
		public static string SerialiseStringArraySafe(string[] array)
		{
			StringBuilder stringBuilder = new StringBuilder();
			foreach (string text in array)
			{
				stringBuilder.Append($"{Encoding.UTF8.GetByteCount(text)}]");
				stringBuilder.Append(text);
			}
			return stringBuilder.ToString();
		}

		public static string[] DeserialiseStringArraySafe(string input)
		{
			byte[] bytes = Encoding.UTF8.GetBytes(input);
			List<string> list = new List<string>();
			int num = 0;
			int num2 = bytes.Length;
			while (num < num2)
			{
				int num3 = 0;
				while (true)
				{
					if (num >= num2)
					{
						throw new FormatException("Invalid input `" + input + "`: reached end while reading length");
					}
					byte b = bytes[num];
					if (b == 93)
					{
						break;
					}
					if (b < 48 || b > 57)
					{
						throw new FormatException($"Invalid input `{input}` at {num}: Got non-digit character while reading length");
					}
					num3 = num3 * 10 + (b - 48);
					num++;
				}
				num++;
				list.Add(Encoding.UTF8.GetString(bytes, num, num3));
				num += num3;
			}
			return list.ToArray();
		}
	}
	public readonly struct SharedStatic<T> where T : struct
	{
		private unsafe readonly void* _buffer;

		private const uint DefaultAlignment = 16u;

		public unsafe ref T Data => ref Unsafe.AsRef<T>(_buffer);

		public unsafe void* UnsafeDataPointer => _buffer;

		private unsafe SharedStatic(void* buffer)
		{
			_buffer = buffer;
		}

		public static SharedStatic<T> GetOrCreate<TContext>(uint alignment = 0u)
		{
			return GetOrCreateUnsafe(alignment, BurstRuntime.GetHashCode64<TContext>(), 0L);
		}

		public static SharedStatic<T> GetOrCreate<TContext, TSubContext>(uint alignment = 0u)
		{
			return GetOrCreateUnsafe(alignment, BurstRuntime.GetHashCode64<TContext>(), BurstRuntime.GetHashCode64<TSubContext>());
		}

		public unsafe static SharedStatic<T> GetOrCreateUnsafe(uint alignment, long hashCode, long subHashCode)
		{
			return new SharedStatic<T>(SharedStatic.GetOrCreateSharedStaticInternal(hashCode, subHashCode, (uint)UnsafeUtility.SizeOf<T>(), (alignment == 0) ? 16u : alignment));
		}

		public unsafe static SharedStatic<T> GetOrCreatePartiallyUnsafeWithHashCode<TSubContext>(uint alignment, long hashCode)
		{
			return new SharedStatic<T>(SharedStatic.GetOrCreateSharedStaticInternal(hashCode, BurstRuntime.GetHashCode64<TSubContext>(), (uint)UnsafeUtility.SizeOf<T>(), (alignment == 0) ? 16u : alignment));
		}

		public unsafe static SharedStatic<T> GetOrCreatePartiallyUnsafeWithSubHashCode<TContext>(uint alignment, long subHashCode)
		{
			return new SharedStatic<T>(SharedStatic.GetOrCreateSharedStaticInternal(BurstRuntime.GetHashCode64<TContext>(), subHashCode, (uint)UnsafeUtility.SizeOf<T>(), (alignment == 0) ? 16u : alignment));
		}

		public static SharedStatic<T> GetOrCreate(Type contextType, uint alignment = 0u)
		{
			return GetOrCreateUnsafe(alignment, BurstRuntime.GetHashCode64(contextType), 0L);
		}

		public static SharedStatic<T> GetOrCreate(Type contextType, Type subContextType, uint alignment = 0u)
		{
			return GetOrCreateUnsafe(alignment, BurstRuntime.GetHashCode64(contextType), BurstRuntime.GetHashCode64(subContextType));
		}

		[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
		private static void CheckIf_T_IsUnmanagedOrThrow()
		{
			if (!UnsafeUtility.IsUnmanaged<T>())
			{
				throw new InvalidOperationException($"The type {typeof(T)} used in SharedStatic<{typeof(T)}> must be unmanaged (contain no managed types).");
			}
		}
	}
	internal static class SharedStatic
	{
		internal class PreserveAttribute : Attribute
		{
		}

		[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
		private static void CheckSizeOf(uint sizeOf)
		{
			if (sizeOf == 0)
			{
				throw new ArgumentException("sizeOf must be > 0", "sizeOf");
			}
		}

		[Conditional("ENABLE_UNITY_COLLECTIONS_CHECKS")]
		private unsafe static void CheckResult(void* result)
		{
			if (result == null)
			{
				throw new InvalidOperationException("Unable to create a SharedStatic for this key. This is most likely due to the size of the struct inside of the SharedStatic having changed or the same key being reused for differently sized values. To fix this the editor needs to be restarted.");
			}
		}

		[Preserve]
		public unsafe static void* GetOrCreateSharedStaticInternal(long getHashCode64, long getSubHashCode64, uint sizeOf, uint alignment)
		{
			Hash128 val = default(Hash128);
			((Hash128)(ref val))..ctor((ulong)getHashCode64, (ulong)getSubHashCode64);
			return BurstCompilerService.GetOrCreateSharedMemory(ref val, sizeOf, alignment);
		}
	}
}
namespace Unity.Burst.Intrinsics
{
	public static class Arm
	{
		public class Neon
		{
			public static bool IsNeonSupported => false;

			public static bool IsNeonArmv82FeaturesSupported => false;

			public static bool IsNeonCryptoSupported => false;

			public static bool IsNeonDotProdSupported => false;

			public static bool IsNeonRDMASupported => false;

			[DebuggerStepThrough]
			public static v64 vadd_s8(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddq_s8(v128 a0, v128 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v64 vadd_s16(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddq_s16(v128 a0, v128 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v64 vadd_s32(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddq_s32(v128 a0, v128 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v64 vadd_s64(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddq_s64(v128 a0, v128 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v64 vadd_u8(v64 a0, v64 a1)
			{
				return vadd_s8(a0, a1);
			}

			[DebuggerStepThrough]
			public static v128 vaddq_u8(v128 a0, v128 a1)
			{
				return vaddq_s8(a0, a1);
			}

			[DebuggerStepThrough]
			public static v64 vadd_u16(v64 a0, v64 a1)
			{
				return vadd_s16(a0, a1);
			}

			[DebuggerStepThrough]
			public static v128 vaddq_u16(v128 a0, v128 a1)
			{
				return vaddq_s16(a0, a1);
			}

			[DebuggerStepThrough]
			public static v64 vadd_u32(v64 a0, v64 a1)
			{
				return vadd_s32(a0, a1);
			}

			[DebuggerStepThrough]
			public static v128 vaddq_u32(v128 a0, v128 a1)
			{
				return vaddq_s32(a0, a1);
			}

			[DebuggerStepThrough]
			public static v64 vadd_u64(v64 a0, v64 a1)
			{
				return vadd_s64(a0, a1);
			}

			[DebuggerStepThrough]
			public static v128 vaddq_u64(v128 a0, v128 a1)
			{
				return vaddq_s64(a0, a1);
			}

			[DebuggerStepThrough]
			public static v64 vadd_f32(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddq_f32(v128 a0, v128 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddl_s8(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddl_s16(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddl_s32(v64 a0, v64 a1)
			{
				throw new NotImplementedException();
			}

			[DebuggerStepThrough]
			public static v128 vaddl_u8(v64 a0, v64 a1)
			{
				throw new NotImplementedExceptio