dotnet_lethal_company-ZString Source

Communities

Lethal CompanyZString

Install

Last Updated

First Uploaded

Downloads

6.4K

Likes

Size

79KB

Dependency string

dotnet_lethal_company-ZString-2.6.1

Dependants

11 other mods

Tools Libraries Misc

Download

Details Required (1)Wiki ~~Changelog~~Versions Analysis

The result has been truncated due to the large size, download it to view the full contents!

using System;
using System.Buffers;
using System.Buffers.Text;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: InternalsVisibleTo("ConsoleApp, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")]
[assembly: InternalsVisibleTo("ConsoleAppNet472, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")]
[assembly: InternalsVisibleTo("ZString.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")]
[assembly: InternalsVisibleTo("ZString.NetCore2Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Cysharp")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© Cysharp, Inc.")]
[assembly: AssemblyDescription("Zero allocation StringBuilder for .NET Core and Unity.")]
[assembly: AssemblyFileVersion("2.6.0.0")]
[assembly: AssemblyInformationalVersion("2.6.0+3156134075b89a162fe95350a2e92a4c85ccca59")]
[assembly: AssemblyProduct("ZString")]
[assembly: AssemblyTitle("ZString")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Cysharp/ZString")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.6.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace System
{
	internal static class BufferEx
	{
		internal unsafe static void ZeroMemory(byte* dest, uint len)
		{
			if (len != 0)
			{
				for (int i = 0; i < len; i++)
				{
					dest[i] = 0;
				}
			}
		}

		internal unsafe static void Memcpy(byte* dest, byte* src, int len)
		{
			if (len != 0)
			{
				for (int i = 0; i < len; i++)
				{
					dest[i] = src[i];
				}
			}
		}
	}
	internal static class DecimalEx
	{
		[StructLayout(LayoutKind.Explicit)]
		private struct DecimalBits
		{
			[FieldOffset(0)]
			public int flags;

			[FieldOffset(4)]
			public int hi;

			[FieldOffset(8)]
			public int lo;

			[FieldOffset(12)]
			public int mid;
		}

		[StructLayout(LayoutKind.Explicit)]
		private struct DecCalc
		{
			private const uint TenToPowerNine = 1000000000u;

			[FieldOffset(0)]
			public uint uflags;

			[FieldOffset(4)]
			public uint uhi;

			[FieldOffset(8)]
			public uint ulo;

			[FieldOffset(12)]
			public uint umid;

			[FieldOffset(8)]
			private ulong ulomidLE;

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

		private const int ScaleShift = 16;

		private static ref DecCalc AsMutable(ref decimal d)
		{
			return ref Unsafe.As<decimal, DecCalc>(ref d);
		}

		internal static uint High(this decimal value)
		{
			return Unsafe.As<decimal, DecCalc>(ref value).uhi;
		}

		internal static uint Low(this decimal value)
		{
			return Unsafe.As<decimal, DecCalc>(ref value).ulo;
		}

		internal static uint Mid(this decimal value)
		{
			return Unsafe.As<decimal, DecCalc>(ref value).umid;
		}

		internal static bool IsNegative(this decimal value)
		{
			return Unsafe.As<decimal, DecimalBits>(ref value).flags < 0;
		}

		internal static int Scale(this decimal value)
		{
			return (byte)(Unsafe.As<decimal, DecimalBits>(ref value).flags >> 16);
		}

		internal static uint DecDivMod1E9(ref decimal value)
		{
			return DecCalc.DecDivMod1E9(ref AsMutable(ref value));
		}
	}
	internal static class FloatEx
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsFinite(double d)
		{
			return (BitConverter.DoubleToInt64Bits(d) & 0x7FFFFFFFFFFFFFFFL) < 9218868437227405312L;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNegative(double d)
		{
			return BitConverter.DoubleToInt64Bits(d) < 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsFinite(float f)
		{
			return (SingleToInt32Bits(f) & 0x7FFFFFFF) < 2139095040;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNegative(float f)
		{
			return SingleToInt32Bits(f) < 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static int SingleToInt32Bits(float value)
		{
			return *(int*)(&value);
		}
	}
	internal struct GuidEx
	{
		private int _a;

		private short _b;

		private short _c;

		private byte _d;

		private byte _e;

		private byte _f;

		private byte _g;

		private byte _h;

		private byte _i;

		private byte _j;

		private byte _k;

		private unsafe static int HexsToChars(char* guidChars, int a, int b)
		{
			*guidChars = System.HexConverter.ToCharLower(a >> 4);
			guidChars[1] = System.HexConverter.ToCharLower(a);
			guidChars[2] = System.HexConverter.ToCharLower(b >> 4);
			guidChars[3] = System.HexConverter.ToCharLower(b);
			return 4;
		}

		private unsafe static int HexsToCharsHexOutput(char* guidChars, int a, int b)
		{
			*guidChars = '0';
			guidChars[1] = 'x';
			guidChars[2] = System.HexConverter.ToCharLower(a >> 4);
			guidChars[3] = System.HexConverter.ToCharLower(a);
			guidChars[4] = ',';
			guidChars[5] = '0';
			guidChars[6] = 'x';
			guidChars[7] = System.HexConverter.ToCharLower(b >> 4);
			guidChars[8] = System.HexConverter.ToCharLower(b);
			return 9;
		}

		public unsafe bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>))
		{
			if (format.Length == 0)
			{
				format = "D".AsSpan();
			}
			if (format.Length != 1)
			{
				throw new FormatException("InvalidGuidFormatSpecification");
			}
			bool flag = true;
			bool flag2 = false;
			int num = 0;
			int num2;
			switch (format[0])
			{
			case 'D':
			case 'd':
				num2 = 36;
				break;
			case 'N':
			case 'n':
				flag = false;
				num2 = 32;
				break;
			case 'B':
			case 'b':
				num = 8192123;
				num2 = 38;
				break;
			case 'P':
			case 'p':
				num = 2687016;
				num2 = 38;
				break;
			case 'X':
			case 'x':
				num = 8192123;
				flag = false;
				flag2 = true;
				num2 = 68;
				break;
			default:
				throw new FormatException("InvalidGuidFormatSpecification");
			}
			if (destination.Length < num2)
			{
				charsWritten = 0;
				return false;
			}
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* ptr2 = ptr;
				if (num != 0)
				{
					*(ptr2++) = (char)num;
				}
				if (flag2)
				{
					*(ptr2++) = '0';
					*(ptr2++) = 'x';
					ptr2 += HexsToChars(ptr2, _a >> 24, _a >> 16);
					ptr2 += HexsToChars(ptr2, _a >> 8, _a);
					*(ptr2++) = ',';
					*(ptr2++) = '0';
					*(ptr2++) = 'x';
					ptr2 += HexsToChars(ptr2, _b >> 8, _b);
					*(ptr2++) = ',';
					*(ptr2++) = '0';
					*(ptr2++) = 'x';
					ptr2 += HexsToChars(ptr2, _c >> 8, _c);
					*(ptr2++) = ',';
					*(ptr2++) = '{';
					ptr2 += HexsToCharsHexOutput(ptr2, _d, _e);
					*(ptr2++) = ',';
					ptr2 += HexsToCharsHexOutput(ptr2, _f, _g);
					*(ptr2++) = ',';
					ptr2 += HexsToCharsHexOutput(ptr2, _h, _i);
					*(ptr2++) = ',';
					ptr2 += HexsToCharsHexOutput(ptr2, _j, _k);
					*(ptr2++) = '}';
				}
				else
				{
					ptr2 += HexsToChars(ptr2, _a >> 24, _a >> 16);
					ptr2 += HexsToChars(ptr2, _a >> 8, _a);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _b >> 8, _b);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _c >> 8, _c);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _d, _e);
					if (flag)
					{
						*(ptr2++) = '-';
					}
					ptr2 += HexsToChars(ptr2, _f, _g);
					ptr2 += HexsToChars(ptr2, _h, _i);
					ptr2 += HexsToChars(ptr2, _j, _k);
				}
				if (num != 0)
				{
					*(ptr2++) = (char)(num >> 16);
				}
			}
			charsWritten = num2;
			return true;
		}
	}
	internal static class HexConverter
	{
		public enum Casing : uint
		{
			Upper = 0u,
			Lower = 8224u
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ToBytesBuffer(byte value, Span<byte> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
		{
			uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209);
			uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing;
			buffer[startingIndex + 1] = (byte)num2;
			buffer[startingIndex] = (byte)(num2 >> 8);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ToCharsBuffer(byte value, Span<char> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
		{
			uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209);
			uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing;
			buffer[startingIndex + 1] = (char)(num2 & 0xFFu);
			buffer[startingIndex] = (char)(num2 >> 8);
		}

		public static string ToString(ReadOnlySpan<byte> bytes, Casing casing = Casing.Upper)
		{
			Span<char> span = default(Span<char>);
			span = ((bytes.Length <= 16) ? stackalloc char[bytes.Length * 2] : new char[bytes.Length * 2].AsSpan());
			int num = 0;
			ReadOnlySpan<byte> readOnlySpan = bytes;
			for (int i = 0; i < readOnlySpan.Length; i++)
			{
				ToCharsBuffer(readOnlySpan[i], span, num, casing);
				num += 2;
			}
			return span.ToString();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char ToCharUpper(int value)
		{
			value &= 0xF;
			value += 48;
			if (value > 57)
			{
				value += 7;
			}
			return (char)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char ToCharLower(int value)
		{
			value &= 0xF;
			value += 48;
			if (value > 57)
			{
				value += 39;
			}
			return (char)value;
		}
	}
	internal static class InternalSpanEx
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool EqualsOrdinalIgnoreCase(this ReadOnlySpan<char> span, ReadOnlySpan<char> value)
		{
			if (span.Length != value.Length)
			{
				return false;
			}
			if (value.Length == 0)
			{
				return true;
			}
			return EqualsOrdinalIgnoreCase(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), span.Length);
		}

		private static bool EqualsOrdinalIgnoreCase(ref char charA, ref char charB, int length)
		{
			IntPtr zero = IntPtr.Zero;
			if (IntPtr.Size == 8)
			{
				while ((uint)length >= 4u)
				{
					ulong num = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, zero)));
					ulong num2 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, zero)));
					ulong num3 = num | num2;
					if (AllCharsInUInt32AreAscii((uint)((int)num3 | (int)(num3 >> 32))))
					{
						if (!UInt64OrdinalIgnoreCaseAscii(num, num2))
						{
							return false;
						}
						zero += 8;
						length -= 4;
						continue;
					}
					goto IL_0101;
				}
			}
			while (true)
			{
				switch (length)
				{
				default:
				{
					uint num6 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, zero)));
					uint num7 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, zero)));
					if (AllCharsInUInt32AreAscii(num6 | num7))
					{
						if (UInt32OrdinalIgnoreCaseAscii(num6, num7))
						{
							goto IL_00aa;
						}
						return false;
					}
					break;
				}
				case 1:
				{
					uint num4 = Unsafe.AddByteOffset(ref charA, zero);
					uint num5 = Unsafe.AddByteOffset(ref charB, zero);
					if ((num4 | num5) <= 127)
					{
						if (num4 == num5)
						{
							return true;
						}
						num4 |= 0x20u;
						if (num4 - 97 > 25)
						{
							return false;
						}
						return num4 == (num5 | 0x20);
					}
					break;
				}
				case 0:
					return true;
				}
				break;
				IL_00aa:
				zero += 4;
				length -= 2;
			}
			goto IL_0101;
			IL_0101:
			return EqualsOrdinalIgnoreCaseNonAscii(ref Unsafe.AddByteOffset(ref charA, zero), ref Unsafe.AddByteOffset(ref charB, zero), length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool AllCharsInUInt32AreAscii(uint value)
		{
			return (value & 0xFF80FF80u) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool AllCharsInUInt64AreAscii(ulong value)
		{
			return (value & 0xFF80FF80FF80FF80uL) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool UInt32OrdinalIgnoreCaseAscii(uint valueA, uint valueB)
		{
			uint num = valueA ^ valueB;
			uint num2 = valueA + 16777472 - 4259905;
			uint num3 = (valueA | 0x200020) + 8388736 - 8061051;
			return ((((num2 | num3) >> 2) | 0xFFDFFFDFu) & num) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool UInt64OrdinalIgnoreCaseAscii(ulong valueA, ulong valueB)
		{
			ulong num = valueA + 36029346783166592L - 18296152663326785L;
			ulong num2 = (valueA | 0x20002000200020L) + 72058693566333184L - 34621950424449147L;
			ulong num3 = (0x80008000800080L & num & num2) >> 2;
			return (valueA | num3) == (valueB | num3);
		}

		private static bool EqualsOrdinalIgnoreCaseNonAscii(ref char charA, ref char charB, int length)
		{
			IntPtr zero = IntPtr.Zero;
			while (length != 0)
			{
				uint num = Unsafe.AddByteOffset(ref charA, zero);
				uint num2 = Unsafe.AddByteOffset(ref charB, zero);
				if (num == num2 || ((num | 0x20) == (num2 | 0x20) && (num | 0x20) - 97 <= 25))
				{
					zero += 2;
					length--;
					continue;
				}
				return false;
			}
			return true;
		}
	}
	internal static class MathEx
	{
		public static uint DivRem(uint a, uint b, out uint result)
		{
			uint num = a / b;
			result = a - num * b;
			return num;
		}

		public static ulong DivRem(ulong a, ulong b, out ulong result)
		{
			ulong num = a / b;
			result = a - num * b;
			return num;
		}

		public static int DivRem(int a, int b, out int result)
		{
			int num = a / b;
			result = a - num * b;
			return num;
		}

		public static long DivRem(long a, long b, out long result)
		{
			long num = a / b;
			result = a - num * b;
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte Clamp(byte value, byte min, byte max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal Clamp(decimal value, decimal min, decimal max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static double Clamp(double value, double min, double max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short Clamp(short value, short min, short max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int Clamp(int value, int min, int max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long Clamp(long value, long min, long max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static sbyte Clamp(sbyte value, sbyte min, sbyte max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static float Clamp(float value, float min, float max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ushort Clamp(ushort value, ushort min, ushort max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint Clamp(uint value, uint min, uint max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong Clamp(ulong value, ulong min, ulong max)
		{
			if (min > max)
			{
				ThrowMinMaxException(min, max);
			}
			if (value < min)
			{
				return min;
			}
			if (value > max)
			{
				return max;
			}
			return value;
		}

		private static void ThrowMinMaxException<T>(T min, T max)
		{
			throw new ArgumentException($"Argument_MinMaxValue, min:{min} max:{max}");
		}
	}
	internal static class Number
	{
		[StructLayout(LayoutKind.Sequential, Pack = 1)]
		internal ref struct BigInteger
		{
			private const int BitsForLongestBinaryMantissa = 1074;

			private const int BitsForLongestDigitSequence = 2552;

			private const int MaxBits = 3658;

			private const int BitsPerBlock = 32;

			private const int MaxBlockCount = 115;

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

			private static readonly int[] s_Pow10BigNumTableIndices = new int[8] { 0, 2, 5, 10, 18, 33, 61, 116 };

			private static readonly uint[] s_Pow10BigNumTable = new uint[233]
			{
				1u, 100000000u, 2u, 1874919424u, 2328306u, 4u, 0u, 2242703233u, 762134875u, 1262u,
				7u, 0u, 0u, 3211403009u, 1849224548u, 3668416493u, 3913284084u, 1593091u, 14u, 0u,
				0u, 0u, 0u, 781532673u, 64985353u, 253049085u, 594863151u, 3553621484u, 3288652808u, 3167596762u,
				2788392729u, 3911132675u, 590u, 27u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 2553183233u, 3201533787u, 3638140786u, 303378311u, 1809731782u, 3477761648u, 3583367183u, 649228654u,
				2915460784u, 487929380u, 1011012442u, 1677677582u, 3428152256u, 1710878487u, 1438394610u, 2161952759u, 4100910556u, 1608314830u,
				349175u, 54u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 4234999809u, 2012377703u,
				2408924892u, 1570150255u, 3090844311u, 3273530073u, 1187251475u, 2498123591u, 3364452033u, 1148564857u, 687371067u, 2854068671u,
				1883165473u, 505794538u, 2988060450u, 3159489326u, 2531348317u, 3215191468u, 849106862u, 3892080979u, 3288073877u, 2242451748u,
				4183778142u, 2995818208u, 2477501924u, 325481258u, 2487842652u, 1774082830u, 1933815724u, 2962865281u, 1168579910u, 2724829000u,
				2360374019u, 2315984659u, 2360052375u, 3251779801u, 1664357844u, 28u, 107u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 689565697u,
				4116392818u, 1853628763u, 516071302u, 2568769159u, 365238920u, 336250165u, 1283268122u, 3425490969u, 248595470u, 2305176814u,
				2111925499u, 507770399u, 2681111421u, 589114268u, 591287751u, 1708941527u, 4098957707u, 475844916u, 3378731398u, 2452339615u,
				2817037361u, 2678008327u, 1656645978u, 2383430340u, 73103988u, 448667107u, 2329420453u, 3124020241u, 3625235717u, 3208634035u,
				2412059158u, 2981664444u, 4117622508u, 838560765u, 3069470027u, 270153238u, 1802868219u, 3692709886u, 2161737865u, 2159912357u,
				2585798786u, 837488486u, 4237238160u, 2540319504u, 3798629246u, 3748148874u, 1021550776u, 2386715342u, 1973637538u, 1823520457u,
				1146713475u, 833971519u, 3277251466u, 905620390u, 26278816u, 2680483154u, 2294040859u, 373297482u, 5996609u, 4109575006u,
				512575049u, 917036550u, 1942311753u, 2816916778u, 3248920332u, 1192784020u, 3537586671u, 2456567643u, 2925660628u, 759380297u,
				888447942u, 3559939476u, 3654687237u, 805u, 0u, 0u, 0u, 0u, 0u, 0u,
				0u, 0u, 0u
			};

			private int _length;

			private unsafe fixed uint _blocks[115];

			public unsafe static void Add(ref BigInteger lhs, ref BigInteger rhs, out BigInteger result)
			{
				ref BigInteger reference = ref lhs._length < rhs._length ? ref rhs : ref lhs;
				ref BigInteger reference2 = ref lhs._length < rhs._length ? ref lhs : ref rhs;
				int length = reference._length;
				int length2 = reference2._length;
				result._length = length;
				ulong num = 0uL;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				while (num3 < length2)
				{
					ulong num5 = num + reference._blocks[num2] + reference2._blocks[num3];
					num = num5 >> 32;
					result._blocks[num4] = (uint)num5;
					num2++;
					num3++;
					num4++;
				}
				while (num2 < length)
				{
					ulong num6 = num + reference._blocks[num2];
					num = num6 >> 32;
					result._blocks[num4] = (uint)num6;
					num2++;
					num4++;
				}
				if (num != 0L)
				{
					result._blocks[num4] = 1u;
					result._length++;
				}
			}

			public unsafe static int Compare(ref BigInteger lhs, ref BigInteger rhs)
			{
				int length = lhs._length;
				int length2 = rhs._length;
				int num = length - length2;
				if (num != 0)
				{
					return num;
				}
				if (length == 0)
				{
					return 0;
				}
				for (int num2 = length - 1; num2 >= 0; num2--)
				{
					long num3 = (long)lhs._blocks[num2] - (long)rhs._blocks[num2];
					if (num3 != 0L)
					{
						if (num3 <= 0)
						{
							return -1;
						}
						return 1;
					}
				}
				return 0;
			}

			public static uint CountSignificantBits(uint value)
			{
				return (uint)(32 - BitOperations.LeadingZeroCount(value));
			}

			public static uint CountSignificantBits(ulong value)
			{
				return (uint)(64 - BitOperations.LeadingZeroCount(value));
			}

			public unsafe static uint CountSignificantBits(ref BigInteger value)
			{
				if (value.IsZero())
				{
					return 0u;
				}
				uint num = (uint)(value._length - 1);
				return num * 32 + CountSignificantBits(value._blocks[num]);
			}

			public unsafe static void DivRem(ref BigInteger lhs, ref BigInteger rhs, out BigInteger quo, out BigInteger rem)
			{
				if (lhs.IsZero())
				{
					SetZero(out quo);
					SetZero(out rem);
					return;
				}
				int length = lhs._length;
				int length2 = rhs._length;
				if (length == 1 && length2 == 1)
				{
					uint result;
					uint value = MathEx.DivRem(lhs._blocks[0], rhs._blocks[0], out result);
					SetUInt32(out quo, value);
					SetUInt32(out rem, result);
					return;
				}
				if (length2 == 1)
				{
					int num = length;
					ulong b = rhs._blocks[0];
					ulong result2 = 0uL;
					for (int num2 = num - 1; num2 >= 0; num2--)
					{
						ulong num3 = MathEx.DivRem((result2 << 32) | lhs._blocks[num2], b, out result2);
						if (num3 == 0L && num2 == num - 1)
						{
							num--;
						}
						else
						{
							quo._blocks[num2] = (uint)num3;
						}
					}
					quo._length = num;
					SetUInt32(out rem, (uint)result2);
					return;
				}
				if (length2 > length)
				{
					SetZero(out quo);
					SetValue(out rem, ref lhs);
					return;
				}
				int num4 = length - length2 + 1;
				SetValue(out rem, ref lhs);
				int num5 = length;
				uint num6 = rhs._blocks[length2 - 1];
				uint num7 = rhs._blocks[length2 - 2];
				int num8 = BitOperations.LeadingZeroCount(num6);
				int num9 = 32 - num8;
				if (num8 > 0)
				{
					num6 = (num6 << num8) | (num7 >> num9);
					num7 <<= num8;
					if (length2 > 2)
					{
						num7 |= rhs._blocks[length2 - 3] >> num9;
					}
				}
				for (int num10 = length; num10 >= length2; num10--)
				{
					int num11 = num10 - length2;
					uint num12 = ((num10 < length) ? rem._blocks[num10] : 0u);
					ulong num13 = ((ulong)num12 << 32) | rem._blocks[num10 - 1];
					uint num14 = ((num10 > 1) ? rem._blocks[num10 - 2] : 0u);
					if (num8 > 0)
					{
						num13 = (num13 << num8) | (num14 >> num9);
						num14 <<= num8;
						if (num10 > 2)
						{
							num14 |= rem._blocks[num10 - 3] >> num9;
						}
					}
					ulong num15 = num13 / num6;
					if (num15 > uint.MaxValue)
					{
						num15 = 4294967295uL;
					}
					while (DivideGuessTooBig(num15, num13, num14, num6, num7))
					{
						num15--;
					}
					if (num15 != 0 && SubtractDivisor(ref rem, num11, ref rhs, num15) != num12)
					{
						AddDivisor(ref rem, num11, ref rhs);
						num15--;
					}
					if (num4 != 0)
					{
						if (num15 == 0L && num11 == num4 - 1)
						{
							num4--;
						}
						else
						{
							quo._blocks[num11] = (uint)num15;
						}
					}
					if (num10 < num5)
					{
						num5--;
					}
				}
				quo._length = num4;
				for (int num16 = num5 - 1; num16 >= 0; num16--)
				{
					if (rem._blocks[num16] == 0)
					{
						num5--;
					}
				}
				rem._length = num5;
			}

			public unsafe static uint HeuristicDivide(ref BigInteger dividend, ref BigInteger divisor)
			{
				int num = divisor._length;
				if (dividend._length < num)
				{
					return 0u;
				}
				int num2 = num - 1;
				uint num3 = dividend._blocks[num2] / (divisor._blocks[num2] + 1);
				if (num3 != 0)
				{
					int num4 = 0;
					ulong num5 = 0uL;
					ulong num6 = 0uL;
					do
					{
						ulong num7 = (ulong)((long)divisor._blocks[num4] * (long)num3) + num6;
						num6 = num7 >> 32;
						ulong num8 = (ulong)((long)dividend._blocks[num4] - (long)(uint)num7) - num5;
						num5 = (num8 >> 32) & 1;
						dividend._blocks[num4] = (uint)num8;
						num4++;
					}
					while (num4 < num);
					while (num > 0 && dividend._blocks[num - 1] == 0)
					{
						num--;
					}
					dividend._length = num;
				}
				if (Compare(ref dividend, ref divisor) >= 0)
				{
					num3++;
					int num9 = 0;
					ulong num10 = 0uL;
					do
					{
						ulong num11 = (ulong)((long)dividend._blocks[num9] - (long)divisor._blocks[num9]) - num10;
						num10 = (num11 >> 32) & 1;
						dividend._blocks[num9] = (uint)num11;
						num9++;
					}
					while (num9 < num);
					while (num > 0 && dividend._blocks[num - 1] == 0)
					{
						num--;
					}
					dividend._length = num;
				}
				return num3;
			}

			public unsafe static void Multiply(ref BigInteger lhs, uint value, out BigInteger result)
			{
				if (!lhs.IsZero())
				{
					switch (value)
					{
					case 1u:
						break;
					case 0u:
						SetZero(out result);
						return;
					default:
					{
						int length = lhs._length;
						int i = 0;
						uint num = 0u;
						for (; i < length; i++)
						{
							ulong num2 = (ulong)((long)lhs._blocks[i] * (long)value + num);
							result._blocks[i] = (uint)num2;
							num = (uint)(num2 >> 32);
						}
						if (num != 0)
						{
							result._blocks[i] = num;
							result._length = length + 1;
						}
						else
						{
							result._length = length;
						}
						return;
					}
					}
				}
				SetValue(out result, ref lhs);
			}

			public unsafe static void Multiply(ref BigInteger lhs, ref BigInteger rhs, out BigInteger result)
			{
				if (lhs.IsZero() || rhs.IsOne())
				{
					SetValue(out result, ref lhs);
					return;
				}
				if (rhs.IsZero())
				{
					SetZero(out result);
					return;
				}
				ref BigInteger reference = ref lhs;
				int length = lhs._length;
				ref BigInteger reference2 = ref rhs;
				int length2 = rhs._length;
				if (length < length2)
				{
					reference = ref rhs;
					length = rhs._length;
					reference2 = ref lhs;
					length2 = lhs._length;
				}
				int num = (result._length = length2 + length);
				BufferEx.ZeroMemory((byte*)result.GetBlocksPointer(), (uint)(num * 4));
				int num2 = 0;
				int num3 = 0;
				while (num2 < length2)
				{
					if (reference2._blocks[num2] != 0)
					{
						int num4 = 0;
						int num5 = num3;
						ulong num6 = 0uL;
						do
						{
							ulong num7 = (ulong)(result._blocks[num5] + (long)reference2._blocks[num2] * (long)reference._blocks[num4]) + num6;
							num6 = num7 >> 32;
							result._blocks[num5] = (uint)num7;
							num5++;
							num4++;
						}
						while (num4 < length);
						result._blocks[num5] = (uint)num6;
					}
					num2++;
					num3++;
				}
				if (num > 0 && result._blocks[num - 1] == 0)
				{
					result._length--;
				}
			}

			public unsafe static void Pow2(uint exponent, out BigInteger result)
			{
				uint remainder;
				uint num = DivRem32(exponent, out remainder);
				result._length = (int)(num + 1);
				if (num != 0)
				{
					BufferEx.ZeroMemory((byte*)result.GetBlocksPointer(), num * 4);
				}
				result._blocks[num] = (uint)(1 << (int)remainder);
			}

			public unsafe static void Pow10(uint exponent, out BigInteger result)
			{
				SetUInt32(out var result2, s_Pow10UInt32Table[exponent & 7]);
				ref BigInteger reference = ref result2;
				SetZero(out var result3);
				ref BigInteger reference2 = ref result3;
				exponent >>= 3;
				uint num = 0u;
				while (exponent != 0)
				{
					if ((exponent & (true ? 1u : 0u)) != 0)
					{
						fixed (uint* ptr = &s_Pow10BigNumTable[s_Pow10BigNumTableIndices[num]])
						{
							Multiply(ref reference, ref *(BigInteger*)ptr, out reference2);
						}
						ref BigInteger reference3 = ref reference2;
						reference2 = ref reference;
						reference = ref reference3;
					}
					num++;
					exponent >>= 1;
				}
				SetValue(out result, ref reference);
			}

			private unsafe static uint AddDivisor(ref BigInteger lhs, int lhsStartIndex, ref BigInteger rhs)
			{
				int length = rhs._length;
				ulong num = 0uL;
				for (int i = 0; i < length; i++)
				{
					ref uint reference = ref lhs._blocks[lhsStartIndex + i];
					ulong num2 = reference + num + rhs._blocks[i];
					reference = (uint)num2;
					num = num2 >> 32;
				}
				return (uint)num;
			}

			private static bool DivideGuessTooBig(ulong q, ulong valHi, uint valLo, uint divHi, uint divLo)
			{
				ulong num = divHi * q;
				ulong num2 = divLo * q;
				num += num2 >> 32;
				num2 &= 0xFFFFFFFFu;
				if (num < valHi)
				{
					return false;
				}
				if (num > valHi)
				{
					return true;
				}
				if (num2 < valLo)
				{
					return false;
				}
				if (num2 > valLo)
				{
					return true;
				}
				return false;
			}

			private unsafe static uint SubtractDivisor(ref BigInteger lhs, int lhsStartIndex, ref BigInteger rhs, ulong q)
			{
				int length = rhs._length;
				ulong num = 0uL;
				for (int i = 0; i < length; i++)
				{
					num += rhs._blocks[i] * q;
					uint num2 = (uint)num;
					num >>= 32;
					ref uint reference = ref lhs._blocks[lhsStartIndex + i];
					if (reference < num2)
					{
						num++;
					}
					reference -= num2;
				}
				return (uint)num;
			}

			public unsafe void Add(uint value)
			{
				int length = _length;
				if (length == 0)
				{
					SetUInt32(out this, value);
					return;
				}
				_blocks[0] += value;
				if (_blocks[0] >= value)
				{
					return;
				}
				for (int i = 1; i < length; i++)
				{
					ref uint reference = ref _blocks[i];
					reference++;
					if (_blocks[i] != 0)
					{
						return;
					}
				}
				_blocks[length] = 1u;
				_length = length + 1;
			}

			public unsafe uint GetBlock(uint index)
			{
				return _blocks[index];
			}

			public int GetLength()
			{
				return _length;
			}

			public unsafe bool IsOne()
			{
				if (_length == 1)
				{
					return _blocks[0] == 1;
				}
				return false;
			}

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

			public void Multiply(uint value)
			{
				Multiply(ref this, value, out this);
			}

			public void Multiply(ref BigInteger value)
			{
				SetValue(out var result, ref this);
				Multiply(ref result, ref value, out this);
			}

			public unsafe void Multiply10()
			{
				if (!IsZero())
				{
					int i = 0;
					int length = _length;
					ulong num = 0uL;
					for (; i < length; i++)
					{
						ulong num2 = _blocks[i];
						ulong num3 = (num2 << 3) + (num2 << 1) + num;
						num = num3 >> 32;
						_blocks[i] = (uint)num3;
					}
					if (num != 0L)
					{
						_blocks[i] = (uint)num;
						_length++;
					}
				}
			}

			public unsafe void MultiplyPow10(uint exponent)
			{
				if (!IsZero())
				{
					Pow10(exponent, out var result);
					if (result._length == 1)
					{
						Multiply(result._blocks[0]);
					}
					else
					{
						Multiply(ref result);
					}
				}
			}

			public unsafe static void SetUInt32(out BigInteger result, uint value)
			{
				if (value == 0)
				{
					SetZero(out result);
					return;
				}
				result._blocks[0] = value;
				result._length = 1;
			}

			public unsafe static void SetUInt64(out BigInteger result, ulong value)
			{
				if (value <= uint.MaxValue)
				{
					SetUInt32(out result, (uint)value);
					return;
				}
				result._blocks[0] = (uint)value;
				result._blocks[1] = (uint)(value >> 32);
				result._length = 2;
			}

			public unsafe static void SetValue(out BigInteger result, ref BigInteger value)
			{
				BufferEx.Memcpy(len: (result._length = value._length) * 4, dest: (byte*)result.GetBlocksPointer(), src: (byte*)value.GetBlocksPointer());
			}

			public static void SetZero(out BigInteger result)
			{
				result._length = 0;
			}

			public unsafe void ShiftLeft(uint shift)
			{
				int length = _length;
				if (length == 0 || shift == 0)
				{
					return;
				}
				uint remainder;
				uint num = DivRem32(shift, out remainder);
				int num2 = length - 1;
				int num3 = num2 + (int)num;
				if (remainder == 0)
				{
					while (num2 >= 0)
					{
						_blocks[num3] = _blocks[num2];
						num2--;
						num3--;
					}
					_length += (int)num;
					BufferEx.ZeroMemory((byte*)GetBlocksPointer(), num * 4);
					return;
				}
				num3++;
				_length = num3 + 1;
				uint num4 = 32 - remainder;
				uint num5 = 0u;
				uint num6 = _blocks[num2];
				uint num7 = num6 >> (int)num4;
				while (num2 > 0)
				{
					_blocks[num3] = num5 | num7;
					num5 = num6 << (int)remainder;
					num2--;
					num3--;
					num6 = _blocks[num2];
					num7 = num6 >> (int)num4;
				}
				_blocks[num3] = num5 | num7;
				_blocks[num3 - 1] = num6 << (int)remainder;
				BufferEx.ZeroMemory((byte*)GetBlocksPointer(), num * 4);
				if (_blocks[_length - 1] == 0)
				{
					_length--;
				}
			}

			public unsafe ulong ToUInt64()
			{
				if (_length > 1)
				{
					return ((ulong)_blocks[1] << 32) + _blocks[0];
				}
				if (_length > 0)
				{
					return _blocks[0];
				}
				return 0uL;
			}

			private unsafe uint* GetBlocksPointer()
			{
				return (uint*)Unsafe.AsPointer(ref _blocks[0]);
			}

			private static uint DivRem32(uint value, out uint remainder)
			{
				remainder = value & 0x1Fu;
				return value >> 5;
			}
		}

		internal readonly ref struct DiyFp
		{
			public const int DoubleImplicitBitIndex = 52;

			public const int SingleImplicitBitIndex = 23;

			public const int SignificandSize = 64;

			public readonly ulong f;

			public readonly int e;

			public static DiyFp CreateAndGetBoundaries(double value, out DiyFp mMinus, out DiyFp mPlus)
			{
				DiyFp result = new DiyFp(value);
				result.GetBoundaries(52, out mMinus, out mPlus);
				return result;
			}

			public static DiyFp CreateAndGetBoundaries(float value, out DiyFp mMinus, out DiyFp mPlus)
			{
				DiyFp result = new DiyFp(value);
				result.GetBoundaries(23, out mMinus, out mPlus);
				return result;
			}

			public DiyFp(double value)
			{
				f = ExtractFractionAndBiasedExponent(value, out e);
			}

			public DiyFp(float value)
			{
				f = ExtractFractionAndBiasedExponent(value, out e);
			}

			public DiyFp(ulong f, int e)
			{
				this.f = f;
				this.e = e;
			}

			public DiyFp Multiply(in DiyFp other)
			{
				int num = (int)(f >> 32);
				uint num2 = (uint)f;
				uint num3 = (uint)(other.f >> 32);
				uint num4 = (uint)other.f;
				ulong num5 = (ulong)(uint)num * (ulong)num3;
				ulong num6 = (ulong)num2 * (ulong)num3;
				ulong num7 = (ulong)(uint)num * (ulong)num4;
				ulong num8 = (ulong)(((long)num2 * (long)num4 >>> 32) + (uint)num7 + (uint)num6);
				num8 += 2147483648u;
				return new DiyFp(num5 + (num7 >> 32) + (num6 >> 32) + (num8 >> 32), e + other.e + 64);
			}

			public DiyFp Normalize()
			{
				int num = BitOperations.LeadingZeroCount(f);
				return new DiyFp(f << num, e - num);
			}

			public DiyFp Subtract(in DiyFp other)
			{
				return new DiyFp(f - other.f, e);
			}

			private void GetBoundaries(int implicitBitIndex, out DiyFp mMinus, out DiyFp mPlus)
			{
				mPlus = new DiyFp((f << 1) + 1, e - 1).Normalize();
				if (f == (ulong)(1L << implicitBitIndex))
				{
					mMinus = new DiyFp((f << 2) - 1, e - 2);
				}
				else
				{
					mMinus = new DiyFp((f << 1) - 1, e - 1);
				}
				mMinus = new DiyFp(mMinus.f << mMinus.e - mPlus.e, mPlus.e);
			}
		}

		internal static class Grisu3
		{
			private const int CachedPowersDecimalExponentDistance = 8;

			private const int CachedPowersMinDecimalExponent = -348;

			private const int CachedPowersPowerMaxDecimalExponent = 340;

			private const int CachedPowersOffset = 348;

			private const double D1Log210 = 0.3010299956639812;

			private const int MaximalTargetExponent = -32;

			private const int MinimalTargetExponent = -60;

			private static readonly short[] s_CachedPowersBinaryExponent = new short[87]
			{
				-1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980,
				-954, -927, -901, -874, -847, -821, -794, -768, -741, -715,
				-688, -661, -635, -608, -582, -555, -529, -502, -475, -449,
				-422, -396, -369, -343, -316, -289, -263, -236, -210, -183,
				-157, -130, -103, -77, -50, -24, 3, 30, 56, 83,
				109, 136, 162, 189, 216, 242, 269, 295, 322, 348,
				375, 402, 428, 455, 481, 508, 534, 561, 588, 614,
				641, 667, 694, 720, 747, 774, 800, 827, 853, 880,
				907, 933, 960, 986, 1013, 1039, 1066
			};

			private static readonly short[] s_CachedPowersDecimalExponent = new short[87]
			{
				-348, -340, -332, -324, -316, -308, -300, -292, -284, -276,
				-268, -260, -252, -244, -236, -228, -220, -212, -204, -196,
				-188, -180, -172, -164, -156, -148, -140, -132, -124, -116,
				-108, -100, -92, -84, -76, -68, -60, -52, -44, -36,
				-28, -20, -12, -4, 4, 12, 20, 28, 36, 44,
				52, 60, 68, 76, 84, 92, 100, 108, 116, 124,
				132, 140, 148, 156, 164, 172, 180, 188, 196, 204,
				212, 220, 228, 236, 244, 252, 260, 268, 276, 284,
				292, 300, 308, 316, 324, 332, 340
			};

			private static readonly ulong[] s_CachedPowersSignificand = new ulong[87]
			{
				18054884314459144840uL, 13451937075301367670uL, 10022474136428063862uL, 14934650266808366570uL, 11127181549972568877uL, 16580792590934885855uL, 12353653155963782858uL, 18408377700990114895uL, 13715310171984221708uL, 10218702384817765436uL,
				15227053142812498563uL, 11345038669416679861uL, 16905424996341287883uL, 12595523146049147757uL, 9384396036005875287uL, 13983839803942852151uL, 10418772551374772303uL, 15525180923007089351uL, 11567161174868858868uL, 17236413322193710309uL,
				12842128665889583758uL, 9568131466127621947uL, 14257626930069360058uL, 10622759856335341974uL, 15829145694278690180uL, 11793632577567316726uL, 17573882009934360870uL, 13093562431584567480uL, 9755464219737475723uL, 14536774485912137811uL,
				10830740992659433045uL, 16139061738043178685uL, 12024538023802026127uL, 17917957937422433684uL, 13349918974505688015uL, 9946464728195732843uL, 14821387422376473014uL, 11042794154864902060uL, 16455045573212060422uL, 12259964326927110867uL,
				18268770466636286478uL, 13611294676837538539uL, 10141204801825835212uL, 15111572745182864684uL, 11258999068426240000uL, 16777216000000000000uL, 12500000000000000000uL, 9313225746154785156uL, 13877787807814456755uL, 10339757656912845936uL,
				15407439555097886824uL, 11479437019748901445uL, 17105694144590052135uL, 12744735289059618216uL, 9495567745759798747uL, 14149498560666738074uL, 10542197943230523224uL, 15709099088952724970uL, 11704190886730495818uL, 17440603504673385349uL,
				12994262207056124023uL, 9681479787123295682uL, 14426529090290212157uL, 10748601772107342003uL, 16016664761464807395uL, 11933345169920330789uL, 17782069995880619868uL, 13248674568444952270uL, 9871031767461413346uL, 14708983551653345445uL,
				10959046745042015199uL, 16330252207878254650uL, 12166986024289022870uL, 18130221999122236476uL, 13508068024458167312uL, 10064294952495520794uL, 14996968138956309548uL, 11173611982879273257uL, 16649979327439178909uL, 12405201291620119593uL,
				9242595204427927429uL, 13772540099066387757uL, 10261342003245940623uL, 15290591125556738113uL, 11392378155556871081uL, 16975966327722178521uL, 12648080533535911531uL
			};

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

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static bool IsNegative(double d)
			{
				return BitConverter.DoubleToInt64Bits(d) < 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static bool IsNegativeInfinity(float f)
			{
				return f == float.NegativeInfinity;
			}

			public static bool TryRunDouble(double value, int requestedDigits, ref NumberBuffer number)
			{
				double value2 = (IsNegative(value) ? (0.0 - value) : value);
				DiyFp diyFp;
				bool flag;
				int length;
				int decimalExponent;
				if (requestedDigits == -1)
				{
					diyFp = DiyFp.CreateAndGetBoundaries(value2, out var mMinus, out var mPlus);
					DiyFp w = diyFp.Normalize();
					flag = TryRunShortest(in mMinus, in w, in mPlus, number.Digits, out length, out decimalExponent);
				}
				else
				{
					diyFp = new DiyFp(value2);
					DiyFp w2 = diyFp.Normalize();
					flag = TryRunCounted(in w2, requestedDigits, number.Digits, out length, out decimalExponent);
				}
				if (flag)
				{
					number.Scale = length + decimalExponent;
					number.Digits[length] = 0;
					number.DigitsCount = length;
				}
				return flag;
			}

			public static bool TryRunSingle(float value, int requestedDigits, ref NumberBuffer number)
			{
				float value2 = (IsNegative(value) ? (0f - value) : value);
				DiyFp diyFp;
				bool flag;
				int length;
				int decimalExponent;
				if (requestedDigits == -1)
				{
					diyFp = DiyFp.CreateAndGetBoundaries(value2, out var mMinus, out var mPlus);
					DiyFp w = diyFp.Normalize();
					flag = TryRunShortest(in mMinus, in w, in mPlus, number.Digits, out length, out decimalExponent);
				}
				else
				{
					diyFp = new DiyFp(value2);
					DiyFp w2 = diyFp.Normalize();
					flag = TryRunCounted(in w2, requestedDigits, number.Digits, out length, out decimalExponent);
				}
				if (flag)
				{
					number.Scale = length + decimalExponent;
					number.Digits[length] = 0;
					number.DigitsCount = length;
				}
				return flag;
			}

			private static bool TryRunCounted(in DiyFp w, int requestedDigits, Span<byte> buffer, out int length, out int decimalExponent)
			{
				int minExponent = -60 - (w.e + 64);
				int maxExponent = -32 - (w.e + 64);
				int decimalExponent2;
				DiyFp other = GetCachedPowerForBinaryExponentRange(minExponent, maxExponent, out decimalExponent2);
				DiyFp w2 = w.Multiply(in other);
				int kappa;
				bool result = TryDigitGenCounted(in w2, requestedDigits, buffer, out length, out kappa);
				decimalExponent = -decimalExponent2 + kappa;
				return result;
			}

			private static bool TryRunShortest(in DiyFp boundaryMinus, in DiyFp w, in DiyFp boundaryPlus, Span<byte> buffer, out int length, out int decimalExponent)
			{
				int minExponent = -60 - (w.e + 64);
				int maxExponent = -32 - (w.e + 64);
				int decimalExponent2;
				DiyFp other = GetCachedPowerForBinaryExponentRange(minExponent, maxExponent, out decimalExponent2);
				DiyFp w2 = w.Multiply(in other);
				DiyFp low = boundaryMinus.Multiply(in other);
				DiyFp high = boundaryPlus.Multiply(in other);
				int kappa;
				bool result = TryDigitGenShortest(in low, in w2, in high, buffer, out length, out kappa);
				decimalExponent = -decimalExponent2 + kappa;
				return result;
			}

			private static uint BiggestPowerTen(uint number, int numberBits, out int exponentPlusOne)
			{
				int num = (numberBits + 1) * 1233 >> 12;
				uint num2 = s_SmallPowersOfTen[num];
				if (number < num2)
				{
					num--;
					num2 = s_SmallPowersOfTen[num];
				}
				exponentPlusOne = num + 1;
				return num2;
			}

			private static bool TryDigitGenCounted(in DiyFp w, int requestedDigits, Span<byte> buffer, out int length, out int kappa)
			{
				ulong num = 1uL;
				DiyFp diyFp = new DiyFp((ulong)(1L << -w.e), w.e);
				uint result = (uint)(w.f >> -diyFp.e);
				ulong num2 = w.f & (diyFp.f - 1);
				if (num2 == 0L && (requestedDigits >= 11 || result < s_SmallPowersOfTen[requestedDigits - 1]))
				{
					length = 0;
					kappa = 0;
					return false;
				}
				uint num3 = BiggestPowerTen(result, 64 - -diyFp.e, out kappa);
				length = 0;
				while (kappa > 0)
				{
					uint num4 = MathEx.DivRem(result, num3, out result);
					buffer[length] = (byte)(48 + num4);
					length++;
					requestedDigits--;
					kappa--;
					if (requestedDigits == 0)
					{
						break;
					}
					num3 /= 10;
				}
				if (requestedDigits == 0)
				{
					ulong rest = ((ulong)result << -diyFp.e) + num2;
					return TryRoundWeedCounted(buffer, length, rest, (ulong)num3 << -diyFp.e, num, ref kappa);
				}
				while (requestedDigits > 0 && num2 > num)
				{
					num2 *= 10;
					num *= 10;
					uint num5 = (uint)(num2 >> -diyFp.e);
					buffer[length] = (byte)(48 + num5);
					length++;
					requestedDigits--;
					kappa--;
					num2 &= diyFp.f - 1;
				}
				if (requestedDigits != 0)
				{
					buffer[0] = 0;
					length = 0;
					kappa = 0;
					return false;
				}
				return TryRoundWeedCounted(buffer, length, num2, diyFp.f, num, ref kappa);
			}

			private static bool TryDigitGenShortest(in DiyFp low, in DiyFp w, in DiyFp high, Span<byte> buffer, out int length, out int kappa)
			{
				ulong num = 1uL;
				DiyFp other = new DiyFp(low.f - num, low.e);
				DiyFp diyFp = new DiyFp(high.f + num, high.e);
				DiyFp diyFp2 = diyFp.Subtract(in other);
				DiyFp diyFp3 = new DiyFp((ulong)(1L << -w.e), w.e);
				uint result = (uint)(diyFp.f >> -diyFp3.e);
				ulong num2 = diyFp.f & (diyFp3.f - 1);
				uint num3 = BiggestPowerTen(result, 64 - -diyFp3.e, out kappa);
				length = 0;
				while (kappa > 0)
				{
					uint num4 = MathEx.DivRem(result, num3, out result);
					buffer[length] = (byte)(48 + num4);
					length++;
					kappa--;
					ulong num5 = ((ulong)result << -diyFp3.e) + num2;
					if (num5 < diyFp2.f)
					{
						return TryRoundWeedShortest(buffer, length, diyFp.Subtract(in w).f, diyFp2.f, num5, (ulong)num3 << -diyFp3.e, num);
					}
					num3 /= 10;
				}
				do
				{
					num2 *= 10;
					num *= 10;
					diyFp2 = new DiyFp(diyFp2.f * 10, diyFp2.e);
					uint num6 = (uint)(num2 >> -diyFp3.e);
					buffer[length] = (byte)(48 + num6);
					length++;
					kappa--;
					num2 &= diyFp3.f - 1;
				}
				while (num2 >= diyFp2.f);
				return TryRoundWeedShortest(buffer, length, diyFp.Subtract(in w).f * num, diyFp2.f, num2, diyFp3.f, num);
			}

			private static DiyFp GetCachedPowerForBinaryExponentRange(int minExponent, int maxExponent, out int decimalExponent)
			{
				double num = Math.Ceiling((double)(minExponent + 64 - 1) * 0.3010299956639812);
				int num2 = (348 + (int)num - 1) / 8 + 1;
				decimalExponent = s_CachedPowersDecimalExponent[num2];
				return new DiyFp(s_CachedPowersSignificand[num2], s_CachedPowersBinaryExponent[num2]);
			}

			private static bool TryRoundWeedCounted(Span<byte> buffer, int length, ulong rest, ulong tenKappa, ulong unit, ref int kappa)
			{
				if (unit >= tenKappa || tenKappa - unit <= unit)
				{
					return false;
				}
				if (tenKappa - rest > rest && tenKappa - 2 * rest >= 2 * unit)
				{
					return true;
				}
				if (rest > unit && (tenKappa <= rest - unit || tenKappa - (rest - unit) <= rest - unit))
				{
					buffer[length - 1]++;
					int num = length - 1;
					while (num > 0 && buffer[num] == 58)
					{
						buffer[num] = 48;
						buffer[num - 1]++;
						num--;
					}
					if (buffer[0] == 58)
					{
						buffer[0] = 49;
						kappa++;
					}
					return true;
				}
				return false;
			}

			private static bool TryRoundWeedShortest(Span<byte> buffer, int length, ulong distanceTooHighW, ulong unsafeInterval, ulong rest, ulong tenKappa, ulong unit)
			{
				ulong num = distanceTooHighW - unit;
				ulong num2 = distanceTooHighW + unit;
				while (rest < num && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num || num - rest >= rest + tenKappa - num))
				{
					buffer[length - 1]--;
					rest += tenKappa;
				}
				if (rest < num2 && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num2 || num2 - rest > rest + tenKappa - num2))
				{
					return false;
				}
				if (2 * unit <= rest)
				{
					return rest <= unsafeInterval - 4 * unit;
				}
				return false;
			}
		}

		internal ref struct NumberBuffer
		{
			public int DigitsCount;

			public int Scale;

			public bool IsNegative;

			public bool HasNonZeroTail;

			public NumberBufferKind Kind;

			public Span<byte> Digits;

			public unsafe NumberBuffer(NumberBufferKind kind, byte* digits, int digitsLength)
			{
				DigitsCount = 0;
				Scale = 0;
				IsNegative = false;
				HasNonZeroTail = false;
				Kind = kind;
				Digits = new Span<byte>(digits, digitsLength);
				Digits[0] = 0;
			}

			[Conditional("DEBUG")]
			public void CheckConsistency()
			{
			}

			public unsafe byte* GetDigitsPointer()
			{
				return (byte*)Unsafe.AsPointer(ref Digits[0]);
			}

			public override string ToString()
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.Append('[');
				stringBuilder.Append('"');
				for (int i = 0; i < Digits.Length; i++)
				{
					byte b = Digits[i];
					if (b == 0)
					{
						break;
					}
					stringBuilder.Append((char)b);
				}
				stringBuilder.Append('"');
				stringBuilder.Append(", Length = ").Append(DigitsCount);
				stringBuilder.Append(", Scale = ").Append(Scale);
				stringBuilder.Append(", IsNegative = ").Append(IsNegative);
				stringBuilder.Append(", HasNonZeroTail = ").Append(HasNonZeroTail);
				stringBuilder.Append(", Kind = ").Append(Kind);
				stringBuilder.Append(']');
				return stringBuilder.ToString();
			}
		}

		internal enum NumberBufferKind : byte
		{
			Unknown,
			Integer,
			Decimal,
			FloatingPoint
		}

		public readonly struct FloatingPointInfo
		{
			public static readonly FloatingPointInfo Double = new FloatingPointInfo(52, 11, 1023, 1023, 9218868437227405312uL);

			public static readonly FloatingPointInfo Single = new FloatingPointInfo(23, 8, 127, 127, 2139095040uL);

			public ulong ZeroBits { get; }

			public ulong InfinityBits { get; }

			public ulong NormalMantissaMask { get; }

			public ulong DenormalMantissaMask { get; }

			public int MinBinaryExponent { get; }

			public int MaxBinaryExponent { get; }

			public int ExponentBias { get; }

			public int OverflowDecimalExponent { get; }

			public ushort NormalMantissaBits { get; }

			public ushort DenormalMantissaBits { get; }

			public ushort ExponentBits { get; }

			public FloatingPointInfo(ushort denormalMantissaBits, ushort exponentBits, int maxBinaryExponent, int exponentBias, ulong infinityBits)
			{
				ExponentBits = exponentBits;
				DenormalMantissaBits = denormalMantissaBits;
				NormalMantissaBits = (ushort)(denormalMantissaBits + 1);
				OverflowDecimalExponent = (maxBinaryExponent + 2 * NormalMantissaBits) / 3;
				ExponentBias = exponentBias;
				MaxBinaryExponent = maxBinaryExponent;
				MinBinaryExponent = 1 - maxBinaryExponent;
				DenormalMantissaMask = (ulong)((1L << (int)denormalMantissaBits) - 1);
				NormalMantissaMask = (ulong)((1L << (int)NormalMantissaBits) - 1);
				InfinityBits = infinityBits;
				ZeroBits = 0uL;
			}
		}

		internal enum ParsingStatus
		{
			OK,
			Failed,
			Overflow
		}

		internal const int DecimalPrecision = 29;

		private const int SinglePrecision = 9;

		private const int DoublePrecision = 17;

		private const int SinglePrecisionCustomFormat = 7;

		private const int DoublePrecisionCustomFormat = 15;

		private const int DefaultPrecisionExponentialFormat = 6;

		private const int MaxUInt32DecDigits = 10;

		private const int CharStackBufferSize = 32;

		private const string PosNumberFormat = "#";

		private static readonly string[] s_singleDigitStringCache = new string[10] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" };

		private static readonly string[] s_posCurrencyFormats = new string[4] { "$#", "#$", "$ #", "# $" };

		private static readonly string[] s_negCurrencyFormats = new string[16]
		{
			"($#)", "-$#", "$-#", "$#-", "(#$)", "-#$", "#-$", "#$-", "-# $", "-$ #",
			"# $-", "$ #-", "$ -#", "#- $", "($ #)", "(# $)"
		};

		private static readonly string[] s_posPercentFormats = new string[4] { "# %", "#%", "%#", "% #" };

		private static readonly string[] s_negPercentFormats = new string[12]
		{
			"-# %", "-#%", "-%#", "%-#", "%#-", "#-%", "#%-", "-% #", "# %-", "% #-",
			"% -#", "#- %"
		};

		private static readonly string[] s_negNumberFormats = new string[5] { "(#)", "-#", "- #", "#-", "# -" };

		internal const int DecimalNumberBufferLength = 31;

		internal const int DoubleNumberBufferLength = 769;

		internal const int Int32NumberBufferLength = 11;

		internal const int Int64NumberBufferLength = 20;

		internal const int SingleNumberBufferLength = 114;

		internal const int UInt32NumberBufferLength = 11;

		internal const int UInt64NumberBufferLength = 21;

		private static readonly float[] s_Pow10SingleTable = new float[11]
		{
			1f, 10f, 100f, 1000f, 10000f, 100000f, 1000000f, 10000000f, 100000000f, 1E+09f,
			1E+10f
		};

		private static readonly double[] s_Pow10DoubleTable = new double[23]
		{
			1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0,
			10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 1E+17, 1E+18, 1E+19,
			1E+20, 1E+21, 1E+22
		};

		private const int Int32Precision = 10;

		private const int UInt32Precision = 10;

		private const int Int64Precision = 19;

		private const int UInt64Precision = 20;

		private const int DoubleMaxExponent = 309;

		private const int DoubleMinExponent = -324;

		private const int FloatingPointMaxExponent = 309;

		private const int FloatingPointMinExponent = -324;

		private const int SingleMaxExponent = 39;

		private const int SingleMinExponent = -45;

		internal static ReadOnlySpan<byte> CharToHexLookup => new byte[103]
		{
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 0, 1,
			2, 3, 4, 5, 6, 7, 8, 9, 255, 255,
			255, 255, 255, 255, 255, 10, 11, 12, 13, 14,
			15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 10, 11, 12,
			13, 14, 15
		};

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsNegative(double d)
		{
			return BitConverter.DoubleToInt64Bits(d) < 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsNegativeInfinity(float f)
		{
			return f == float.NegativeInfinity;
		}

		public static void Dragon4Double(double value, int cutoffNumber, bool isSignificantDigits, ref NumberBuffer number)
		{
			IsNegative(value);
			int exponent;
			ulong num = ExtractFractionAndBiasedExponent(value, out exponent);
			bool hasUnequalMargins = false;
			uint mantissaHighBitIdx;
			if (num >> 52 != 0L)
			{
				mantissaHighBitIdx = 52u;
				hasUnequalMargins = num == 4503599627370496L;
			}
			else
			{
				mantissaHighBitIdx = (uint)BitOperations.Log2(num);
			}
			int decimalExponent;
			int num2 = (int)Dragon4(num, exponent, mantissaHighBitIdx, hasUnequalMargins, cutoffNumber, isSignificantDigits, number.Digits, out decimalExponent);
			number.Scale = decimalExponent + 1;
			number.Digits[num2] = 0;
			number.DigitsCount = num2;
		}

		public static void Dragon4Single(float value, int cutoffNumber, bool isSignificantDigits, ref NumberBuffer number)
		{
			IsNegative(value);
			int exponent;
			uint num = ExtractFractionAndBiasedExponent(value, out exponent);
			bool hasUnequalMargins = false;
			uint mantissaHighBitIdx;
			if (num >> 23 != 0)
			{
				mantissaHighBitIdx = 23u;
				hasUnequalMargins = num == 8388608;
			}
			else
			{
				mantissaHighBitIdx = (uint)BitOperations.Log2(num);
			}
			int decimalExponent;
			int num2 = (int)Dragon4(num, exponent, mantissaHighBitIdx, hasUnequalMargins, cutoffNumber, isSignificantDigits, number.Digits, out decimalExponent);
			number.Scale = decimalExponent + 1;
			number.Digits[num2] = 0;
			number.DigitsCount = num2;
		}

		private unsafe static uint Dragon4(ulong mantissa, int exponent, uint mantissaHighBitIdx, bool hasUnequalMargins, int cutoffNumber, bool isSignificantDigits, Span<byte> buffer, out int decimalExponent)
		{
			int num = 0;
			BigInteger result;
			BigInteger result2;
			BigInteger result3;
			BigInteger* ptr;
			if (hasUnequalMargins)
			{
				BigInteger result4;
				if (exponent > 0)
				{
					BigInteger.SetUInt64(out result, 4 * mantissa);
					result.ShiftLeft((uint)exponent);
					BigInteger.SetUInt32(out result2, 4u);
					BigInteger.Pow2((uint)exponent, out result3);
					BigInteger.Pow2((uint)(exponent + 1), out result4);
				}
				else
				{
					BigInteger.SetUInt64(out result, 4 * mantissa);
					BigInteger.Pow2((uint)(-exponent + 2), out result2);
					BigInteger.SetUInt32(out result3, 1u);
					BigInteger.SetUInt32(out result4, 2u);
				}
				ptr = &result4;
			}
			else
			{
				if (exponent > 0)
				{
					BigInteger.SetUInt64(out result, 2 * mantissa);
					result.ShiftLeft((uint)exponent);
					BigInteger.SetUInt32(out result2, 2u);
					BigInteger.Pow2((uint)exponent, out result3);
				}
				else
				{
					BigInteger.SetUInt64(out result, 2 * mantissa);
					BigInteger.Pow2((uint)(-exponent + 1), out result2);
					BigInteger.SetUInt32(out result3, 1u);
				}
				ptr = &result3;
			}
			int num2 = (int)Math.Ceiling((double)((int)mantissaHighBitIdx + exponent) * 0.3010299956639812 - 0.69);
			if (num2 > 0)
			{
				result2.MultiplyPow10((uint)num2);
			}
			else if (num2 < 0)
			{
				BigInteger.Pow10((uint)(-num2), out var result5);
				result.Multiply(ref result5);
				result3.Multiply(ref result5);
				if (ptr != &result3)
				{
					BigInteger.Multiply(ref result3, 2u, out *ptr);
				}
			}
			bool flag = mantissa % 2 == 0;
			bool flag2 = false;
			if (cutoffNumber == -1)
			{
				BigInteger.Add(ref result, ref *ptr, out var result6);
				int num3 = BigInteger.Compare(ref result6, ref result2);
				flag2 = (flag ? (num3 >= 0) : (num3 > 0));
			}
			else
			{
				flag2 = BigInteger.Compare(ref result, ref result2) >= 0;
			}
			if (flag2)
			{
				num2++;
			}
			else
			{
				result.Multiply10();
				result3.Multiply10();
				if (ptr != &result3)
				{
					BigInteger.Multiply(ref result3, 2u, out *ptr);
				}
			}
			int num4 = num2 - buffer.Length;
			if (cutoffNumber != -1)
			{
				int num5 = 0;
				num5 = ((!isSignificantDigits) ? (-cutoffNumber) : (num2 - cutoffNumber));
				if (num5 > num4)
				{
					num4 = num5;
				}
			}
			num2 = (decimalExponent = num2 - 1);
			uint block = result2.GetBlock((uint)(result2.GetLength() - 1));
			if (block < 8 || block > 429496729)
			{
				uint num6 = (uint)BitOperations.Log2(block);
				uint shift = (59 - num6) % 32;
				result2.ShiftLeft(shift);
				result.ShiftLeft(shift);
				result3.ShiftLeft(shift);
				if (ptr != &result3)
				{
					BigInteger.Multiply(ref result3, 2u, out *ptr);
				}
			}
			bool flag3;
			bool flag4;
			uint num7;
			if (cutoffNumber == -1)
			{
				while (true)
				{
					num7 = BigInteger.HeuristicDivide(ref result, ref result2);
					BigInteger.Add(ref result, ref *ptr, out var result7);
					int num8 = BigInteger.Compare(ref result, ref result3);
					int num9 = BigInteger.Compare(ref result7, ref result2);
					if (flag)
					{
						flag3 = num8 <= 0;
						flag4 = num9 >= 0;
					}
					else
					{
						flag3 = num8 < 0;
						flag4 = num9 > 0;
					}
					if (flag3 || flag4 || num2 == num4)
					{
						break;
					}
					buffer[num] = (byte)(48 + num7);
					num++;
					result.Multiply10();
					result3.Multiply10();
					if (ptr != &result3)
					{
						BigInteger.Multiply(ref result3, 2u, out *ptr);
					}
					num2--;
				}
			}
			else
			{
				if (num2 < num4)
				{
					num7 = BigInteger.HeuristicDivide(ref result, ref result2);
					if (num7 > 5 || (num7 == 5 && !result.IsZero()))
					{
						decimalExponent++;
						num7 = 1u;
					}
					buffer[num] = (byte)(48 + num7);
					return (uint)(num + 1);
				}
				flag3 = false;
				flag4 = false;
				while (true)
				{
					num7 = BigInteger.HeuristicDivide(ref result, ref result2);
					if (result.IsZero() || num2 <= num4)
					{
						break;
					}
					buffer[num] = (byte)(48 + num7);
					num++;
					result.Multiply10();
					num2--;
				}
			}
			bool flag5 = flag3;
			if (flag3 == flag4)
			{
				result.ShiftLeft(1u);
				int num10 = BigInteger.Compare(ref result, ref result2);
				flag5 = num10 < 0;
				if (num10 == 0)
				{
					flag5 = (num7 & 1) == 0;
				}
			}
			if (flag5)
			{
				buffer[num] = (byte)(48 + num7);
				num++;
			}
			else if (num7 == 9)
			{
				while (true)
				{
					if (num == 0)
					{
						buffer[num] = 49;
						num++;
						decimalExponent++;
						break;
					}
					num--;
					if (buffer[num] != 57)
					{
						buffer[num]++;
						num++;
						break;
					}
				}
			}
			else
			{
				buffer[num] = (byte)(48 + num7 + 1);
				num++;
			}
			return (uint)num;
		}

		public unsafe static string FormatDecimal(decimal value, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[31];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Decimal, digits2, 31);
			DecimalToNumber(ref value, ref number);
			char* pointer = stackalloc char[32];
			System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
			if (c != 0)
			{
				NumberToString(ref sb, ref number, c, digits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return sb.ToString();
		}

		public unsafe static bool TryFormatDecimal(decimal value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
		{
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[31];
			NumberBuffer number = new NumberBuffer(NumberBufferKind.Decimal, digits2, 31);
			DecimalToNumber(ref value, ref number);
			char* pointer = stackalloc char[32];
			System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
			if (c != 0)
			{
				NumberToString(ref sb, ref number, c, digits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return sb.TryCopyTo(destination, out charsWritten);
		}

		internal unsafe static void DecimalToNumber(ref decimal d, ref NumberBuffer number)
		{
			byte* digitsPointer = number.GetDigitsPointer();
			number.DigitsCount = 29;
			number.IsNegative = d.IsNegative();
			byte* bufferEnd = digitsPointer + 29;
			while ((d.Mid() | d.High()) != 0)
			{
				bufferEnd = UInt32ToDecChars(bufferEnd, DecimalEx.DecDivMod1E9(ref d), 9);
			}
			bufferEnd = UInt32ToDecChars(bufferEnd, d.Low(), 0);
			int num = (number.DigitsCount = (int)(digitsPointer + 29 - bufferEnd));
			number.Scale = num - d.Scale();
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(bufferEnd++);
			}
			*digitsPointer2 = 0;
		}

		public static string FormatDouble(double value, string format, NumberFormatInfo info)
		{
			Span<char> initialBuffer = stackalloc char[32];
			System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer);
			return FormatDouble(ref sb, value, format.AsSpan(), info) ?? sb.ToString();
		}

		public static bool TryFormatDouble(double value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
		{
			Span<char> initialBuffer = stackalloc char[32];
			System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer);
			string text = FormatDouble(ref sb, value, format, info);
			if (text == null)
			{
				return sb.TryCopyTo(destination, out charsWritten);
			}
			return TryCopyTo(text, destination, out charsWritten);
		}

		private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int precision, NumberFormatInfo info, out bool isSignificantDigits)
		{
			if (fmt == '\0')
			{
				isSignificantDigits = true;
				return precision;
			}
			int result = precision;
			switch (fmt)
			{
			case 'C':
			case 'c':
				if (precision == -1)
				{
					precision = info.CurrencyDecimalDigits;
				}
				isSignificantDigits = false;
				break;
			case 'E':
			case 'e':
				if (precision == -1)
				{
					precision = 6;
				}
				precision++;
				isSignificantDigits = true;
				break;
			case 'F':
			case 'N':
			case 'f':
			case 'n':
				if (precision == -1)
				{
					precision = info.NumberDecimalDigits;
				}
				isSignificantDigits = false;
				break;
			case 'G':
			case 'g':
				if (precision == 0)
				{
					precision = -1;
				}
				isSignificantDigits = true;
				break;
			case 'P':
			case 'p':
				if (precision == -1)
				{
					precision = info.PercentDecimalDigits;
				}
				precision += 2;
				isSignificantDigits = false;
				break;
			case 'R':
			case 'r':
				precision = -1;
				isSignificantDigits = true;
				break;
			default:
				throw new FormatException("SR.Argument_BadFormatSpecifier");
			}
			return result;
		}

		private unsafe static string FormatDouble(ref System.Text.ValueStringBuilder sb, double value, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			if (!FloatEx.IsFinite(value))
			{
				if (double.IsNaN(value))
				{
					return info.NaNSymbol;
				}
				if (!FloatEx.IsNegative(value))
				{
					return info.PositiveInfinitySymbol;
				}
				return info.NegativeInfinitySymbol;
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[769];
			if (c == '\0')
			{
				digits = 15;
			}
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits2, 769);
			number.IsNegative = FloatEx.IsNegative(value);
			bool isSignificantDigits;
			int nMaxDigits = GetFloatingPointMaxDigitsAndPrecision(c, ref digits, info, out isSignificantDigits);
			if (value != 0.0 && (!isSignificantDigits || !Grisu3.TryRunDouble(value, digits, ref number)))
			{
				Dragon4Double(value, digits, isSignificantDigits, ref number);
			}
			if (c != 0)
			{
				if (digits == -1)
				{
					nMaxDigits = Math.Max(number.DigitsCount, 17);
				}
				NumberToString(ref sb, ref number, c, nMaxDigits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return null;
		}

		public static string FormatSingle(float value, string format, NumberFormatInfo info)
		{
			Span<char> initialBuffer = stackalloc char[32];
			System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer);
			return FormatSingle(ref sb, value, format.AsSpan(), info) ?? sb.ToString();
		}

		public static bool TryFormatSingle(float value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten)
		{
			Span<char> initialBuffer = stackalloc char[32];
			System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer);
			string text = FormatSingle(ref sb, value, format, info);
			if (text == null)
			{
				return sb.TryCopyTo(destination, out charsWritten);
			}
			return TryCopyTo(text, destination, out charsWritten);
		}

		private unsafe static string FormatSingle(ref System.Text.ValueStringBuilder sb, float value, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			if (!FloatEx.IsFinite(value))
			{
				if (float.IsNaN(value))
				{
					return info.NaNSymbol;
				}
				if (!FloatEx.IsNegative(value))
				{
					return info.PositiveInfinitySymbol;
				}
				return info.NegativeInfinitySymbol;
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			byte* digits2 = stackalloc byte[114];
			if (c == '\0')
			{
				digits = 7;
			}
			NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits2, 114);
			number.IsNegative = FloatEx.IsNegative(value);
			bool isSignificantDigits;
			int nMaxDigits = GetFloatingPointMaxDigitsAndPrecision(c, ref digits, info, out isSignificantDigits);
			if (value != 0f && (!isSignificantDigits || !Grisu3.TryRunSingle(value, digits, ref number)))
			{
				Dragon4Single(value, digits, isSignificantDigits, ref number);
			}
			if (c != 0)
			{
				if (digits == -1)
				{
					nMaxDigits = Math.Max(number.DigitsCount, 9);
				}
				NumberToString(ref sb, ref number, c, nMaxDigits, info);
			}
			else
			{
				NumberToStringFormat(ref sb, ref number, format, info);
			}
			return null;
		}

		private static bool TryCopyTo(string source, Span<char> destination, out int charsWritten)
		{
			if (source.AsSpan().TryCopyTo(destination))
			{
				charsWritten = source.Length;
				return true;
			}
			charsWritten = 0;
			return false;
		}

		public unsafe static string FormatInt32(int value, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			if (value >= 0 && format.Length == 0)
			{
				return UInt32ToDecStr((uint)value, -1);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return Int32ToHexStr(value, (char)(c - 33), digits);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[11];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
					Int32ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.ToString();
				}
				}
			}
			if (value < 0)
			{
				return NegativeInt32ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign);
			}
			return UInt32ToDecStr((uint)value, digits);
		}

		public unsafe static bool TryFormatInt32(int value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (value >= 0 && format.Length == 0)
			{
				return TryUInt32ToDecStr((uint)value, -1, destination, out charsWritten);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return TryInt32ToHexStr(value, (char)(c - 33), digits, destination, out charsWritten);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[11];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
					Int32ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.TryCopyTo(destination, out charsWritten);
				}
				}
			}
			if (value < 0)
			{
				return TryNegativeInt32ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten);
			}
			return TryUInt32ToDecStr((uint)value, digits, destination, out charsWritten);
		}

		public unsafe static string FormatUInt32(uint value, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			if (format.Length == 0)
			{
				return UInt32ToDecStr(value, -1);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return Int32ToHexStr((int)value, (char)(c - 33), digits);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[11];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
					UInt32ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.ToString();
				}
				}
			}
			return UInt32ToDecStr(value, digits);
		}

		public unsafe static bool TryFormatUInt32(uint value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (format.Length == 0)
			{
				return TryUInt32ToDecStr(value, -1, destination, out charsWritten);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return TryInt32ToHexStr((int)value, (char)(c - 33), digits, destination, out charsWritten);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[11];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11);
					UInt32ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.TryCopyTo(destination, out charsWritten);
				}
				}
			}
			return TryUInt32ToDecStr(value, digits, destination, out charsWritten);
		}

		public unsafe static string FormatInt64(long value, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			if (value >= 0 && format.Length == 0)
			{
				return UInt64ToDecStr((ulong)value, -1);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return Int64ToHexStr(value, (char)(c - 33), digits);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[20];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 20);
					Int64ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.ToString();
				}
				}
			}
			if (value < 0)
			{
				return NegativeInt64ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign);
			}
			return UInt64ToDecStr((ulong)value, digits);
		}

		public unsafe static bool TryFormatInt64(long value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (value >= 0 && format.Length == 0)
			{
				return TryUInt64ToDecStr((ulong)value, -1, destination, out charsWritten);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return TryInt64ToHexStr(value, (char)(c - 33), digits, destination, out charsWritten);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[20];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 20);
					Int64ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.TryCopyTo(destination, out charsWritten);
				}
				}
			}
			if (value < 0)
			{
				return TryNegativeInt64ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten);
			}
			return TryUInt64ToDecStr((ulong)value, digits, destination, out charsWritten);
		}

		public unsafe static string FormatUInt64(ulong value, ReadOnlySpan<char> format, IFormatProvider provider)
		{
			if (format.Length == 0)
			{
				return UInt64ToDecStr(value, -1);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return Int64ToHexStr((long)value, (char)(c - 33), digits);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[21];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 21);
					UInt64ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.ToString();
				}
				}
			}
			return UInt64ToDecStr(value, digits);
		}

		public unsafe static bool TryFormatUInt64(ulong value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten)
		{
			if (format.Length == 0)
			{
				return TryUInt64ToDecStr(value, -1, destination, out charsWritten);
			}
			int digits;
			char c = ParseFormatSpecifier(format, out digits);
			char c2 = (char)(c & 0xFFDFu);
			if (c2 != 'G' || digits >= 1)
			{
				switch (c2)
				{
				case 'D':
					break;
				case 'X':
					return TryInt64ToHexStr((long)value, (char)(c - 33), digits, destination, out charsWritten);
				default:
				{
					NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider);
					byte* digits2 = stackalloc byte[21];
					NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 21);
					UInt64ToNumber(value, ref number);
					char* pointer = stackalloc char[32];
					System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32));
					if (c != 0)
					{
						NumberToString(ref sb, ref number, c, digits, instance);
					}
					else
					{
						NumberToStringFormat(ref sb, ref number, format, instance);
					}
					return sb.TryCopyTo(destination, out charsWritten);
				}
				}
			}
			return TryUInt64ToDecStr(value, digits, destination, out charsWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static void Int32ToNumber(int value, ref NumberBuffer number)
		{
			number.DigitsCount = 10;
			if (value >= 0)
			{
				number.IsNegative = false;
			}
			else
			{
				number.IsNegative = true;
				value = -value;
			}
			byte* digitsPointer = number.GetDigitsPointer();
			byte* ptr = UInt32ToDecChars(digitsPointer + 10, (uint)value, 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 10 - ptr)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(ptr++);
			}
			*digitsPointer2 = 0;
		}

		private unsafe static string NegativeInt32ToDecStr(int value, int digits, string sNegative)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length;
			string text = FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* ptr2 = UInt32ToDecChars(ptr + num, (uint)(-value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--ptr2) = sNegative[num2];
				}
			}
			return text;
		}

		private unsafe static bool TryNegativeInt32ToDecStr(int value, int digits, string sNegative, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length;
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* ptr2 = UInt32ToDecChars(ptr + num, (uint)(-value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--ptr2) = sNegative[num2];
				}
			}
			return true;
		}

		private unsafe static string Int32ToHexStr(int value, char hexBase, int digits)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((uint)value));
			string text = FastAllocateString(num);
			fixed (char* ptr = text)
			{
				Int32ToHexChars(ptr + num, (uint)value, hexBase, digits);
			}
			return text;
		}

		private unsafe static bool TryInt32ToHexStr(int value, char hexBase, int digits, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((uint)value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				Int32ToHexChars(ptr + num, (uint)value, hexBase, digits);
			}
			return true;
		}

		private unsafe static char* Int32ToHexChars(char* buffer, uint value, int hexBase, int digits)
		{
			while (--digits >= 0 || value != 0)
			{
				byte b = (byte)(value & 0xFu);
				*(--buffer) = (char)(b + ((b < 10) ? 48 : hexBase));
				value >>= 4;
			}
			return buffer;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static void UInt32ToNumber(uint value, ref NumberBuffer number)
		{
			number.DigitsCount = 10;
			number.IsNegative = false;
			byte* digitsPointer = number.GetDigitsPointer();
			byte* ptr = UInt32ToDecChars(digitsPointer + 10, value, 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 10 - ptr)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(ptr++);
			}
			*digitsPointer2 = 0;
		}

		internal unsafe static byte* UInt32ToDecChars(byte* bufferEnd, uint value, int digits)
		{
			while (--digits >= 0 || value != 0)
			{
				value = MathEx.DivRem(value, 10u, out var result);
				*(--bufferEnd) = (byte)(result + 48);
			}
			return bufferEnd;
		}

		internal unsafe static char* UInt32ToDecChars(char* bufferEnd, uint value, int digits)
		{
			while (--digits >= 0 || value != 0)
			{
				value = MathEx.DivRem(value, 10u, out var result);
				*(--bufferEnd) = (char)(result + 48);
			}
			return bufferEnd;
		}

		internal unsafe static string UInt32ToDecStr(uint value, int digits)
		{
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value));
			if (num == 1)
			{
				return s_singleDigitStringCache[value];
			}
			string text = FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* ptr2 = ptr + num;
				if (digits <= 1)
				{
					do
					{
						value = MathEx.DivRem(value, 10u, out var result);
						*(--ptr2) = (char)(result + 48);
					}
					while (value != 0);
				}
				else
				{
					ptr2 = UInt32ToDecChars(ptr2, value, digits);
				}
			}
			return text;
		}

		private unsafe static bool TryUInt32ToDecStr(uint value, int digits, Span<char> destination, out int charsWritten)
		{
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* ptr2 = ptr + num;
				if (digits <= 1)
				{
					do
					{
						value = MathEx.DivRem(value, 10u, out var result);
						*(--ptr2) = (char)(result + 48);
					}
					while (value != 0);
				}
				else
				{
					ptr2 = UInt32ToDecChars(ptr2, value, digits);
				}
			}
			return true;
		}

		private unsafe static void Int64ToNumber(long input, ref NumberBuffer number)
		{
			ulong value = (ulong)input;
			number.IsNegative = input < 0;
			number.DigitsCount = 19;
			if (number.IsNegative)
			{
				value = (ulong)(-input);
			}
			byte* digitsPointer = number.GetDigitsPointer();
			byte* bufferEnd = digitsPointer + 19;
			while (High32(value) != 0)
			{
				bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
			}
			bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 19 - bufferEnd)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(bufferEnd++);
			}
			*digitsPointer2 = 0;
		}

		private unsafe static string NegativeInt64ToDecStr(long input, int digits, string sNegative)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			ulong value = (ulong)(-input);
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value)) + sNegative.Length;
			string text = FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--bufferEnd) = sNegative[num2];
				}
			}
			return text;
		}

		private unsafe static bool TryNegativeInt64ToDecStr(long input, int digits, string sNegative, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			ulong value = (ulong)(-input);
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits((ulong)(-input))) + sNegative.Length;
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
				for (int num2 = sNegative.Length - 1; num2 >= 0; num2--)
				{
					*(--bufferEnd) = sNegative[num2];
				}
			}
			return true;
		}

		private unsafe static string Int64ToHexStr(long value, char hexBase, int digits)
		{
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((ulong)value));
			string text = FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* buffer = ptr + num;
				if (High32((ulong)value) != 0)
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, 8);
					buffer = Int32ToHexChars(buffer, High32((ulong)value), hexBase, digits - 8);
				}
				else
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, Math.Max(digits, 1));
				}
			}
			return text;
		}

		private unsafe static bool TryInt64ToHexStr(long value, char hexBase, int digits, Span<char> destination, out int charsWritten)
		{
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((ulong)value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* buffer = ptr + num;
				if (High32((ulong)value) != 0)
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, 8);
					buffer = Int32ToHexChars(buffer, High32((ulong)value), hexBase, digits - 8);
				}
				else
				{
					buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, Math.Max(digits, 1));
				}
			}
			return true;
		}

		private unsafe static void UInt64ToNumber(ulong value, ref NumberBuffer number)
		{
			number.DigitsCount = 20;
			number.IsNegative = false;
			byte* digitsPointer = number.GetDigitsPointer();
			byte* bufferEnd = digitsPointer + 20;
			while (High32(value) != 0)
			{
				bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
			}
			bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), 0);
			int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 20 - bufferEnd)));
			byte* digitsPointer2 = number.GetDigitsPointer();
			while (--num >= 0)
			{
				*(digitsPointer2++) = *(bufferEnd++);
			}
			*digitsPointer2 = 0;
		}

		internal unsafe static string UInt64ToDecStr(ulong value, int digits)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value));
			if (num == 1)
			{
				return s_singleDigitStringCache[value];
			}
			string text = FastAllocateString(num);
			fixed (char* ptr = text)
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
			}
			return text;
		}

		private unsafe static bool TryUInt64ToDecStr(ulong value, int digits, Span<char> destination, out int charsWritten)
		{
			if (digits < 1)
			{
				digits = 1;
			}
			int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value));
			if (num > destination.Length)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(destination))
			{
				char* bufferEnd = ptr + num;
				while (High32(value) != 0)
				{
					bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9);
					digits -= 9;
				}
				bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits);
			}
			return true;
		}

		internal static char ParseFormatSpecifier(ReadOnlySpan<char> format, out int digits)
		{
			char c = '\0';
			if (format.Length > 0)
			{
				c = format[0];
				if ((uint)(c - 65) <= 25u || (uint)(c - 97) <= 25u)
				{
					if (format.Length == 1)
					{
						digits = -1;
						return c;
					}
					if (format.Length == 2)
					{
						int num = format[1] - 48;
						if ((uint)num < 10u)
						{
							digits = num;
							return c;
						}
					}
					else if (format.Length == 3)
					{
						int num2 = format[1] - 48;
						int num3 = format[2] - 48;
						if ((uint)num2 < 10u && (uint)num3 < 10u)
						{
							digits = num2 * 10 + num3;
							return c;
						}
					}
					int num4 = 0;
					int num5 = 1;
					while (num5 < format.Length && (uint)(format[num5] - 48) < 10u && num4 < 10)
					{
						num4 = num4 * 10 + format[num5++] - 48;
					}
					if (num5 == format.Length || format[num5] == '\0')
					{
						digits = num4;
						return c;
					}
				}
			}
			digits = -1;
			if (format.Length != 0 && c != 0)
			{
				return '\0';
			}
			return 'G';
		}

		internal static void NumberToString(ref System.Text.ValueStringBuilder sb, ref NumberBuffer number, char format, int nMaxDigits, NumberFormatInfo info)
		{
			bool isCorrectlyRounded = number.Kind == NumberBufferKind.FloatingPoint;
			bool bSuppressScientific;
			switch (format)
			{
			case 'C':
			case 'c':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.CurrencyDecimalDigits;
				}
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				FormatCurrency(ref sb, ref number, nMaxDigits, info);
				return;
			case 'F':
			case 'f':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.NumberDecimalDigits;
				}
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				if (number.IsNegative)
				{
					sb.Append(info.NegativeSign);
				}
				FormatFixed(ref sb, ref number, nMaxDigits, null, info.NumberDecimalSeparator, null);
				return;
			case 'N':
			case 'n':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.NumberDecimalDigits;
				}
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				FormatNumber(ref sb, ref number, nMaxDigits, info);
				return;
			case 'E':
			case 'e':
				if (nMaxDigits < 0)
				{
					nMaxDigits = 6;
				}
				nMaxDigits++;
				RoundNumber(ref number, nMaxDigits, isCorrectlyRounded);
				if (number.IsNegative)
				{
					sb.Append(info.NegativeSign);
				}
				FormatScientific(ref sb, ref number, nMaxDigits, info, format);
				return;
			case 'G':
			case 'g':
				bSuppressScientific = false;
				if (nMaxDigits < 1)
				{
					if (number.Kind == NumberBufferKind.Decimal && nMaxDigits == -1)
					{
						bSuppressScientific = true;
						if (number.Digits[0] != 0)
						{
							goto IL_0189;
						}
						goto IL_019e;
					}
					nMaxDigits = number.DigitsCount;
				}
				RoundNumber(ref number, nMaxDigits, isCorrectlyRounded);
				goto IL_0189;
			case 'P':
			case 'p':
				if (nMaxDigits < 0)
				{
					nMaxDigits = info.PercentDecimalDigits;
				}
				number.Scale += 2;
				RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded);
				FormatPercent(ref sb, ref number, nMaxDigits, info);
				return;
			case 'R':
			case 'r':
				{
					if (number.Kind != NumberBufferKind.FloatingPoint)
					{
						break;
					}
					format = (char)(format - 11);
					goto case 'G';
				}
				IL_0189:
				if (number.IsNegative)
				{
					sb.Append(info.NegativeSign);
				}
				goto IL_019e;
				IL_019e:
				FormatGeneral(ref sb, ref number, nMaxDigits, info, (char)(format - 2), bSuppressScientific);
				return;
			}
			throw new FormatException("SR.Argument_BadFormatSpecifier");
		}

		internal unsafe static void NumberToStringFormat(ref System.Text.ValueStringBuilder sb, ref NumberBuffer number, ReadOnlySpan<char> format, NumberFormatInfo info)
		{
			int num = 0;
			byte* digitsPointer = number.GetDigitsPointer();
			int num2 = FindSection(format, (*digitsPointer == 0) ? 2 : (number.IsNegative ? 1 : 0));
			int num3;
			int num4;
			bool flag;
			bool flag2;
			int num5;
			int num6;
			int num9;
			while (true)
			{
				num3 = 0;
				num4 = -1;
				num5 = int.MaxValue;
				num6 = 0;
				flag = false;
				int num7 = -1;
				flag2 = false;
				int num8 = 0;
				num9 = num2;
				fixed (char* ptr = &MemoryMarshal.GetReference(format))
				{
					char c;
					while (num9 < format.Length && (c = ptr[num9++]) != 0)
					{
						switch (c)
						{
						case ';':
							break;
						case '#':
							num3++;
							continue;
						case '0':
							if (num5 == int.MaxValue)
							{
								num5 = num3;
							}
							num3++;
							num6 = num3;
							continue;
						case '.':
							if (num4 < 0)
							{
								num4 = num3;
							}
							continue;
						case ',':
							if (num3 <= 0 || num4 >= 0)
							{
								continue;
							}
							if (num7 >= 0)
							{
								if (num7 == num3)
								{
									num++;
									continue;
								}
								flag2 = true;
							}
							num7 = num3;
							num = 1;
							continue;
						case '%':
							num8 += 2;
							continue;
						case '‰':
							num8 += 3;
							continue;
						case '"':
						case '\'':
							while (num9 < format.Length && ptr[num9] != 0 && ptr[num9++] != c)
							{
							}
							continue;
						case '\\':
							if (num9 < format.Length && ptr[num9] != 0)
							{
								num9++;
							}
							continue;
						case 'E':
						case 'e':
							if ((num9 < format.Length && ptr[num9] == '0') || (num9 + 1 < format.Length && (ptr[num9] == '+' || ptr[num9] == '-') && ptr[num9 + 1] == '0'))
							{
								while (++num9 < format.Length && ptr[num9] == '0')
								{
								}
								flag = true;
							}
							continue;
						default:
							continue;
						}
						break;
					}
				}
				if (num4 < 0)
				{
					num4 = num3;
				}
				if (num7 >= 0)
				{
					if (num7 == num4)
					{
						num8 -= num * 3;
					}
					else
					{
						flag2 = true;
					}
				}
				if (*digitsPointer != 0)
				{
					number.Scale += num8;
					int pos = (flag ? num3 : (number.Scale + num3 - num4));
					RoundNumber(ref number, pos, isCorrectlyRounded: false);
					if (*digitsPointer != 0)
					{
						break;
					}
					num9 = FindSection(format, 2);
					if (num9 == num2)
					{
						break;
					}
					num2 = num9;
					continue;
				}
				if (number.Kind != NumberBufferKind.FloatingPoint)
				{
					number.IsNegative = false;
				}
				number.Scale = 0;
				break;
			}
			num5 = ((num5 < num4) ? (num4 - num5) : 0);
			num6 = ((num6 > num4) ? (num4 - num6) : 0);
			int num10;
			int num11;
			if (flag)
			{
				num10 = num4;
				num11 = 0;
			}
			else
			{
				num10 = ((number.Scale > num4) ? number.Scale : num4);
				num11 = number.Scale - num4;
			}
			num9 = num2;
			Span<int> span = stackalloc int[4];
			int num12 = -1;
			if (flag2 && info.NumberGroupSeparator.Length > 0)
			{
				int[] numberGroupSizes = info.NumberGroupSizes;
				int num13 = 0;
				int i = 0;
				int num14 = numberGroupSizes.Length;
				if (num14 != 0)
				{
					i = numberGroupSizes[num13];
				}
				int num15 = i;
				int num16 = num10 + ((num11 < 0) ? num11 : 0);
				for (int num17 = ((num5 > num16) ? num5 : num16); num17 > i; i += num15)
				{
					if (num15 == 0)
					{
						break;
					}
					num12++;
					if (num12 >= span.Length)
					{
						int[] array = new int[span.Length * 2];
						span.CopyTo(array);
						span = array;
					}
					span[num12] = i;
					if (num13 < num14 - 1)
					{
						num13++;
						num15 = numberGroupSizes[num13];
					}
				}
			}
			if (number.IsNegative && num2 == 0 && number.Scale != 0)
			{
				sb.Append(info.NegativeSign);
			}
			bool flag3 = false;

using System; using System.Buffers; using System.Buffers.Text; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.IO; using System.Linq; using System.Numerics; using System.Reflection; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using System.Security; using System.Security.Permissions; using System.Text; using System.Threading; using System.Threading.Tasks; using Microsoft.CodeAnalysis; [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)] [assembly: InternalsVisibleTo("ConsoleApp, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")] [assembly: InternalsVisibleTo("ConsoleAppNet472, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")] [assembly: InternalsVisibleTo("ZString.Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")] [assembly: InternalsVisibleTo("ZString.NetCore2Tests, PublicKey=00240000048000009400000006020000002400005253413100040000010001000144ec28f1e9ef7b17dacc47425a7a153aea0a7baa590743a2d1a86f4b3e10a8a12712c6e647966bfd8bd6e830048b23bd42bbc56f179585c15b8c19cf86c0eed1b73c993dd7a93a30051dd50fdda0e4d6b65e6874e30f1c37cf8bcbc7fe02c7f2e6a0a3327c0ccc1631bf645f40732521fa0b41a30c178d08f7dd779d42a1ee")] [assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")] [assembly: AssemblyCompany("Cysharp")] [assembly: AssemblyConfiguration("Release")] [assembly: AssemblyCopyright("© Cysharp, Inc.")] [assembly: AssemblyDescription("Zero allocation StringBuilder for .NET Core and Unity.")] [assembly: AssemblyFileVersion("2.6.0.0")] [assembly: AssemblyInformationalVersion("2.6.0+3156134075b89a162fe95350a2e92a4c85ccca59")] [assembly: AssemblyProduct("ZString")] [assembly: AssemblyTitle("ZString")] [assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/Cysharp/ZString")] [assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)] [assembly: AssemblyVersion("2.6.0.0")] [module: UnverifiableCode] namespace Microsoft.CodeAnalysis { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] internal sealed class EmbeddedAttribute : Attribute { } } namespace System.Runtime.CompilerServices { [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)] internal sealed class NullableAttribute : Attribute { public readonly byte[] NullableFlags; public NullableAttribute(byte P_0) { NullableFlags = new byte[1] { P_0 }; } public NullableAttribute(byte[] P_0) { NullableFlags = P_0; } } [CompilerGenerated] [Microsoft.CodeAnalysis.Embedded] [AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)] internal sealed class NullableContextAttribute : Attribute { public readonly byte Flag; public NullableContextAttribute(byte P_0) { Flag = P_0; } } } namespace System { internal static class BufferEx { internal unsafe static void ZeroMemory(byte* dest, uint len) { if (len != 0) { for (int i = 0; i < len; i++) { dest[i] = 0; } } } internal unsafe static void Memcpy(byte* dest, byte* src, int len) { if (len != 0) { for (int i = 0; i < len; i++) { dest[i] = src[i]; } } } } internal static class DecimalEx { [StructLayout(LayoutKind.Explicit)] private struct DecimalBits { [FieldOffset(0)] public int flags; [FieldOffset(4)] public int hi; [FieldOffset(8)] public int lo; [FieldOffset(12)] public int mid; } [StructLayout(LayoutKind.Explicit)] private struct DecCalc { private const uint TenToPowerNine = 1000000000u; [FieldOffset(0)] public uint uflags; [FieldOffset(4)] public uint uhi; [FieldOffset(8)] public uint ulo; [FieldOffset(12)] public uint umid; [FieldOffset(8)] private ulong ulomidLE; internal static uint DecDivMod1E9(ref DecCalc value) { ulong num = ((ulong)value.uhi << 32) + value.umid; ulong num2 = num / 1000000000; value.uhi = (uint)(num2 >> 32); value.umid = (uint)num2; ulong num3 = (num - (uint)((int)num2 * 1000000000) << 32) + value.ulo; return (uint)(int)num3 - (value.ulo = (uint)(num3 / 1000000000)) * 1000000000; } } private const int ScaleShift = 16; private static ref DecCalc AsMutable(ref decimal d) { return ref Unsafe.As<decimal, DecCalc>(ref d); } internal static uint High(this decimal value) { return Unsafe.As<decimal, DecCalc>(ref value).uhi; } internal static uint Low(this decimal value) { return Unsafe.As<decimal, DecCalc>(ref value).ulo; } internal static uint Mid(this decimal value) { return Unsafe.As<decimal, DecCalc>(ref value).umid; } internal static bool IsNegative(this decimal value) { return Unsafe.As<decimal, DecimalBits>(ref value).flags < 0; } internal static int Scale(this decimal value) { return (byte)(Unsafe.As<decimal, DecimalBits>(ref value).flags >> 16); } internal static uint DecDivMod1E9(ref decimal value) { return DecCalc.DecDivMod1E9(ref AsMutable(ref value)); } } internal static class FloatEx { [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsFinite(double d) { return (BitConverter.DoubleToInt64Bits(d) & 0x7FFFFFFFFFFFFFFFL) < 9218868437227405312L; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsNegative(double d) { return BitConverter.DoubleToInt64Bits(d) < 0; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsFinite(float f) { return (SingleToInt32Bits(f) & 0x7FFFFFFF) < 2139095040; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsNegative(float f) { return SingleToInt32Bits(f) < 0; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public unsafe static int SingleToInt32Bits(float value) { return *(int*)(&value); } } internal struct GuidEx { private int _a; private short _b; private short _c; private byte _d; private byte _e; private byte _f; private byte _g; private byte _h; private byte _i; private byte _j; private byte _k; private unsafe static int HexsToChars(char* guidChars, int a, int b) { *guidChars = System.HexConverter.ToCharLower(a >> 4); guidChars[1] = System.HexConverter.ToCharLower(a); guidChars[2] = System.HexConverter.ToCharLower(b >> 4); guidChars[3] = System.HexConverter.ToCharLower(b); return 4; } private unsafe static int HexsToCharsHexOutput(char* guidChars, int a, int b) { *guidChars = '0'; guidChars[1] = 'x'; guidChars[2] = System.HexConverter.ToCharLower(a >> 4); guidChars[3] = System.HexConverter.ToCharLower(a); guidChars[4] = ','; guidChars[5] = '0'; guidChars[6] = 'x'; guidChars[7] = System.HexConverter.ToCharLower(b >> 4); guidChars[8] = System.HexConverter.ToCharLower(b); return 9; } public unsafe bool TryFormat(Span<char> destination, out int charsWritten, ReadOnlySpan<char> format = default(ReadOnlySpan<char>)) { if (format.Length == 0) { format = "D".AsSpan(); } if (format.Length != 1) { throw new FormatException("InvalidGuidFormatSpecification"); } bool flag = true; bool flag2 = false; int num = 0; int num2; switch (format[0]) { case 'D': case 'd': num2 = 36; break; case 'N': case 'n': flag = false; num2 = 32; break; case 'B': case 'b': num = 8192123; num2 = 38; break; case 'P': case 'p': num = 2687016; num2 = 38; break; case 'X': case 'x': num = 8192123; flag = false; flag2 = true; num2 = 68; break; default: throw new FormatException("InvalidGuidFormatSpecification"); } if (destination.Length < num2) { charsWritten = 0; return false; } fixed (char* ptr = &MemoryMarshal.GetReference(destination)) { char* ptr2 = ptr; if (num != 0) { *(ptr2++) = (char)num; } if (flag2) { *(ptr2++) = '0'; *(ptr2++) = 'x'; ptr2 += HexsToChars(ptr2, _a >> 24, _a >> 16); ptr2 += HexsToChars(ptr2, _a >> 8, _a); *(ptr2++) = ','; *(ptr2++) = '0'; *(ptr2++) = 'x'; ptr2 += HexsToChars(ptr2, _b >> 8, _b); *(ptr2++) = ','; *(ptr2++) = '0'; *(ptr2++) = 'x'; ptr2 += HexsToChars(ptr2, _c >> 8, _c); *(ptr2++) = ','; *(ptr2++) = '{'; ptr2 += HexsToCharsHexOutput(ptr2, _d, _e); *(ptr2++) = ','; ptr2 += HexsToCharsHexOutput(ptr2, _f, _g); *(ptr2++) = ','; ptr2 += HexsToCharsHexOutput(ptr2, _h, _i); *(ptr2++) = ','; ptr2 += HexsToCharsHexOutput(ptr2, _j, _k); *(ptr2++) = '}'; } else { ptr2 += HexsToChars(ptr2, _a >> 24, _a >> 16); ptr2 += HexsToChars(ptr2, _a >> 8, _a); if (flag) { *(ptr2++) = '-'; } ptr2 += HexsToChars(ptr2, _b >> 8, _b); if (flag) { *(ptr2++) = '-'; } ptr2 += HexsToChars(ptr2, _c >> 8, _c); if (flag) { *(ptr2++) = '-'; } ptr2 += HexsToChars(ptr2, _d, _e); if (flag) { *(ptr2++) = '-'; } ptr2 += HexsToChars(ptr2, _f, _g); ptr2 += HexsToChars(ptr2, _h, _i); ptr2 += HexsToChars(ptr2, _j, _k); } if (num != 0) { *(ptr2++) = (char)(num >> 16); } } charsWritten = num2; return true; } } internal static class HexConverter { public enum Casing : uint { Upper = 0u, Lower = 8224u } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void ToBytesBuffer(byte value, Span<byte> buffer, int startingIndex = 0, Casing casing = Casing.Upper) { uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209); uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing; buffer[startingIndex + 1] = (byte)num2; buffer[startingIndex] = (byte)(num2 >> 8); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static void ToCharsBuffer(byte value, Span<char> buffer, int startingIndex = 0, Casing casing = Casing.Upper) { uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209); uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing; buffer[startingIndex + 1] = (char)(num2 & 0xFFu); buffer[startingIndex] = (char)(num2 >> 8); } public static string ToString(ReadOnlySpan<byte> bytes, Casing casing = Casing.Upper) { Span<char> span = default(Span<char>); span = ((bytes.Length <= 16) ? stackalloc char[bytes.Length * 2] : new char[bytes.Length * 2].AsSpan()); int num = 0; ReadOnlySpan<byte> readOnlySpan = bytes; for (int i = 0; i < readOnlySpan.Length; i++) { ToCharsBuffer(readOnlySpan[i], span, num, casing); num += 2; } return span.ToString(); } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static char ToCharUpper(int value) { value &= 0xF; value += 48; if (value > 57) { value += 7; } return (char)value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static char ToCharLower(int value) { value &= 0xF; value += 48; if (value > 57) { value += 39; } return (char)value; } } internal static class InternalSpanEx { [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static bool EqualsOrdinalIgnoreCase(this ReadOnlySpan<char> span, ReadOnlySpan<char> value) { if (span.Length != value.Length) { return false; } if (value.Length == 0) { return true; } return EqualsOrdinalIgnoreCase(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), span.Length); } private static bool EqualsOrdinalIgnoreCase(ref char charA, ref char charB, int length) { IntPtr zero = IntPtr.Zero; if (IntPtr.Size == 8) { while ((uint)length >= 4u) { ulong num = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, zero))); ulong num2 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, zero))); ulong num3 = num | num2; if (AllCharsInUInt32AreAscii((uint)((int)num3 | (int)(num3 >> 32)))) { if (!UInt64OrdinalIgnoreCaseAscii(num, num2)) { return false; } zero += 8; length -= 4; continue; } goto IL_0101; } } while (true) { switch (length) { default: { uint num6 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, zero))); uint num7 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, zero))); if (AllCharsInUInt32AreAscii(num6 | num7)) { if (UInt32OrdinalIgnoreCaseAscii(num6, num7)) { goto IL_00aa; } return false; } break; } case 1: { uint num4 = Unsafe.AddByteOffset(ref charA, zero); uint num5 = Unsafe.AddByteOffset(ref charB, zero); if ((num4 | num5) <= 127) { if (num4 == num5) { return true; } num4 |= 0x20u; if (num4 - 97 > 25) { return false; } return num4 == (num5 | 0x20); } break; } case 0: return true; } break; IL_00aa: zero += 4; length -= 2; } goto IL_0101; IL_0101: return EqualsOrdinalIgnoreCaseNonAscii(ref Unsafe.AddByteOffset(ref charA, zero), ref Unsafe.AddByteOffset(ref charB, zero), length); } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static bool AllCharsInUInt32AreAscii(uint value) { return (value & 0xFF80FF80u) == 0; } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static bool AllCharsInUInt64AreAscii(ulong value) { return (value & 0xFF80FF80FF80FF80uL) == 0; } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static bool UInt32OrdinalIgnoreCaseAscii(uint valueA, uint valueB) { uint num = valueA ^ valueB; uint num2 = valueA + 16777472 - 4259905; uint num3 = (valueA | 0x200020) + 8388736 - 8061051; return ((((num2 | num3) >> 2) | 0xFFDFFFDFu) & num) == 0; } [MethodImpl(MethodImplOptions.AggressiveInlining)] internal static bool UInt64OrdinalIgnoreCaseAscii(ulong valueA, ulong valueB) { ulong num = valueA + 36029346783166592L - 18296152663326785L; ulong num2 = (valueA | 0x20002000200020L) + 72058693566333184L - 34621950424449147L; ulong num3 = (0x80008000800080L & num & num2) >> 2; return (valueA | num3) == (valueB | num3); } private static bool EqualsOrdinalIgnoreCaseNonAscii(ref char charA, ref char charB, int length) { IntPtr zero = IntPtr.Zero; while (length != 0) { uint num = Unsafe.AddByteOffset(ref charA, zero); uint num2 = Unsafe.AddByteOffset(ref charB, zero); if (num == num2 || ((num | 0x20) == (num2 | 0x20) && (num | 0x20) - 97 <= 25)) { zero += 2; length--; continue; } return false; } return true; } } internal static class MathEx { public static uint DivRem(uint a, uint b, out uint result) { uint num = a / b; result = a - num * b; return num; } public static ulong DivRem(ulong a, ulong b, out ulong result) { ulong num = a / b; result = a - num * b; return num; } public static int DivRem(int a, int b, out int result) { int num = a / b; result = a - num * b; return num; } public static long DivRem(long a, long b, out long result) { long num = a / b; result = a - num * b; return num; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static byte Clamp(byte value, byte min, byte max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static decimal Clamp(decimal value, decimal min, decimal max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static double Clamp(double value, double min, double max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static short Clamp(short value, short min, short max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static int Clamp(int value, int min, int max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static long Clamp(long value, long min, long max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static sbyte Clamp(sbyte value, sbyte min, sbyte max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static float Clamp(float value, float min, float max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ushort Clamp(ushort value, ushort min, ushort max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static uint Clamp(uint value, uint min, uint max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static ulong Clamp(ulong value, ulong min, ulong max) { if (min > max) { ThrowMinMaxException(min, max); } if (value < min) { return min; } if (value > max) { return max; } return value; } private static void ThrowMinMaxException<T>(T min, T max) { throw new ArgumentException($"Argument_MinMaxValue, min:{min} max:{max}"); } } internal static class Number { [StructLayout(LayoutKind.Sequential, Pack = 1)] internal ref struct BigInteger { private const int BitsForLongestBinaryMantissa = 1074; private const int BitsForLongestDigitSequence = 2552; private const int MaxBits = 3658; private const int BitsPerBlock = 32; private const int MaxBlockCount = 115; private static readonly uint[] s_Pow10UInt32Table = new uint[8] { 1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u }; private static readonly int[] s_Pow10BigNumTableIndices = new int[8] { 0, 2, 5, 10, 18, 33, 61, 116 }; private static readonly uint[] s_Pow10BigNumTable = new uint[233] { 1u, 100000000u, 2u, 1874919424u, 2328306u, 4u, 0u, 2242703233u, 762134875u, 1262u, 7u, 0u, 0u, 3211403009u, 1849224548u, 3668416493u, 3913284084u, 1593091u, 14u, 0u, 0u, 0u, 0u, 781532673u, 64985353u, 253049085u, 594863151u, 3553621484u, 3288652808u, 3167596762u, 2788392729u, 3911132675u, 590u, 27u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 2553183233u, 3201533787u, 3638140786u, 303378311u, 1809731782u, 3477761648u, 3583367183u, 649228654u, 2915460784u, 487929380u, 1011012442u, 1677677582u, 3428152256u, 1710878487u, 1438394610u, 2161952759u, 4100910556u, 1608314830u, 349175u, 54u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 4234999809u, 2012377703u, 2408924892u, 1570150255u, 3090844311u, 3273530073u, 1187251475u, 2498123591u, 3364452033u, 1148564857u, 687371067u, 2854068671u, 1883165473u, 505794538u, 2988060450u, 3159489326u, 2531348317u, 3215191468u, 849106862u, 3892080979u, 3288073877u, 2242451748u, 4183778142u, 2995818208u, 2477501924u, 325481258u, 2487842652u, 1774082830u, 1933815724u, 2962865281u, 1168579910u, 2724829000u, 2360374019u, 2315984659u, 2360052375u, 3251779801u, 1664357844u, 28u, 107u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 689565697u, 4116392818u, 1853628763u, 516071302u, 2568769159u, 365238920u, 336250165u, 1283268122u, 3425490969u, 248595470u, 2305176814u, 2111925499u, 507770399u, 2681111421u, 589114268u, 591287751u, 1708941527u, 4098957707u, 475844916u, 3378731398u, 2452339615u, 2817037361u, 2678008327u, 1656645978u, 2383430340u, 73103988u, 448667107u, 2329420453u, 3124020241u, 3625235717u, 3208634035u, 2412059158u, 2981664444u, 4117622508u, 838560765u, 3069470027u, 270153238u, 1802868219u, 3692709886u, 2161737865u, 2159912357u, 2585798786u, 837488486u, 4237238160u, 2540319504u, 3798629246u, 3748148874u, 1021550776u, 2386715342u, 1973637538u, 1823520457u, 1146713475u, 833971519u, 3277251466u, 905620390u, 26278816u, 2680483154u, 2294040859u, 373297482u, 5996609u, 4109575006u, 512575049u, 917036550u, 1942311753u, 2816916778u, 3248920332u, 1192784020u, 3537586671u, 2456567643u, 2925660628u, 759380297u, 888447942u, 3559939476u, 3654687237u, 805u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u }; private int _length; private unsafe fixed uint _blocks[115]; public unsafe static void Add(ref BigInteger lhs, ref BigInteger rhs, out BigInteger result) { ref BigInteger reference = ref lhs._length < rhs._length ? ref rhs : ref lhs; ref BigInteger reference2 = ref lhs._length < rhs._length ? ref lhs : ref rhs; int length = reference._length; int length2 = reference2._length; result._length = length; ulong num = 0uL; int num2 = 0; int num3 = 0; int num4 = 0; while (num3 < length2) { ulong num5 = num + reference._blocks[num2] + reference2._blocks[num3]; num = num5 >> 32; result._blocks[num4] = (uint)num5; num2++; num3++; num4++; } while (num2 < length) { ulong num6 = num + reference._blocks[num2]; num = num6 >> 32; result._blocks[num4] = (uint)num6; num2++; num4++; } if (num != 0L) { result._blocks[num4] = 1u; result._length++; } } public unsafe static int Compare(ref BigInteger lhs, ref BigInteger rhs) { int length = lhs._length; int length2 = rhs._length; int num = length - length2; if (num != 0) { return num; } if (length == 0) { return 0; } for (int num2 = length - 1; num2 >= 0; num2--) { long num3 = (long)lhs._blocks[num2] - (long)rhs._blocks[num2]; if (num3 != 0L) { if (num3 <= 0) { return -1; } return 1; } } return 0; } public static uint CountSignificantBits(uint value) { return (uint)(32 - BitOperations.LeadingZeroCount(value)); } public static uint CountSignificantBits(ulong value) { return (uint)(64 - BitOperations.LeadingZeroCount(value)); } public unsafe static uint CountSignificantBits(ref BigInteger value) { if (value.IsZero()) { return 0u; } uint num = (uint)(value._length - 1); return num * 32 + CountSignificantBits(value._blocks[num]); } public unsafe static void DivRem(ref BigInteger lhs, ref BigInteger rhs, out BigInteger quo, out BigInteger rem) { if (lhs.IsZero()) { SetZero(out quo); SetZero(out rem); return; } int length = lhs._length; int length2 = rhs._length; if (length == 1 && length2 == 1) { uint result; uint value = MathEx.DivRem(lhs._blocks[0], rhs._blocks[0], out result); SetUInt32(out quo, value); SetUInt32(out rem, result); return; } if (length2 == 1) { int num = length; ulong b = rhs._blocks[0]; ulong result2 = 0uL; for (int num2 = num - 1; num2 >= 0; num2--) { ulong num3 = MathEx.DivRem((result2 << 32) | lhs._blocks[num2], b, out result2); if (num3 == 0L && num2 == num - 1) { num--; } else { quo._blocks[num2] = (uint)num3; } } quo._length = num; SetUInt32(out rem, (uint)result2); return; } if (length2 > length) { SetZero(out quo); SetValue(out rem, ref lhs); return; } int num4 = length - length2 + 1; SetValue(out rem, ref lhs); int num5 = length; uint num6 = rhs._blocks[length2 - 1]; uint num7 = rhs._blocks[length2 - 2]; int num8 = BitOperations.LeadingZeroCount(num6); int num9 = 32 - num8; if (num8 > 0) { num6 = (num6 << num8) | (num7 >> num9); num7 <<= num8; if (length2 > 2) { num7 |= rhs._blocks[length2 - 3] >> num9; } } for (int num10 = length; num10 >= length2; num10--) { int num11 = num10 - length2; uint num12 = ((num10 < length) ? rem._blocks[num10] : 0u); ulong num13 = ((ulong)num12 << 32) | rem._blocks[num10 - 1]; uint num14 = ((num10 > 1) ? rem._blocks[num10 - 2] : 0u); if (num8 > 0) { num13 = (num13 << num8) | (num14 >> num9); num14 <<= num8; if (num10 > 2) { num14 |= rem._blocks[num10 - 3] >> num9; } } ulong num15 = num13 / num6; if (num15 > uint.MaxValue) { num15 = 4294967295uL; } while (DivideGuessTooBig(num15, num13, num14, num6, num7)) { num15--; } if (num15 != 0 && SubtractDivisor(ref rem, num11, ref rhs, num15) != num12) { AddDivisor(ref rem, num11, ref rhs); num15--; } if (num4 != 0) { if (num15 == 0L && num11 == num4 - 1) { num4--; } else { quo._blocks[num11] = (uint)num15; } } if (num10 < num5) { num5--; } } quo._length = num4; for (int num16 = num5 - 1; num16 >= 0; num16--) { if (rem._blocks[num16] == 0) { num5--; } } rem._length = num5; } public unsafe static uint HeuristicDivide(ref BigInteger dividend, ref BigInteger divisor) { int num = divisor._length; if (dividend._length < num) { return 0u; } int num2 = num - 1; uint num3 = dividend._blocks[num2] / (divisor._blocks[num2] + 1); if (num3 != 0) { int num4 = 0; ulong num5 = 0uL; ulong num6 = 0uL; do { ulong num7 = (ulong)((long)divisor._blocks[num4] * (long)num3) + num6; num6 = num7 >> 32; ulong num8 = (ulong)((long)dividend._blocks[num4] - (long)(uint)num7) - num5; num5 = (num8 >> 32) & 1; dividend._blocks[num4] = (uint)num8; num4++; } while (num4 < num); while (num > 0 && dividend._blocks[num - 1] == 0) { num--; } dividend._length = num; } if (Compare(ref dividend, ref divisor) >= 0) { num3++; int num9 = 0; ulong num10 = 0uL; do { ulong num11 = (ulong)((long)dividend._blocks[num9] - (long)divisor._blocks[num9]) - num10; num10 = (num11 >> 32) & 1; dividend._blocks[num9] = (uint)num11; num9++; } while (num9 < num); while (num > 0 && dividend._blocks[num - 1] == 0) { num--; } dividend._length = num; } return num3; } public unsafe static void Multiply(ref BigInteger lhs, uint value, out BigInteger result) { if (!lhs.IsZero()) { switch (value) { case 1u: break; case 0u: SetZero(out result); return; default: { int length = lhs._length; int i = 0; uint num = 0u; for (; i < length; i++) { ulong num2 = (ulong)((long)lhs._blocks[i] * (long)value + num); result._blocks[i] = (uint)num2; num = (uint)(num2 >> 32); } if (num != 0) { result._blocks[i] = num; result._length = length + 1; } else { result._length = length; } return; } } } SetValue(out result, ref lhs); } public unsafe static void Multiply(ref BigInteger lhs, ref BigInteger rhs, out BigInteger result) { if (lhs.IsZero() || rhs.IsOne()) { SetValue(out result, ref lhs); return; } if (rhs.IsZero()) { SetZero(out result); return; } ref BigInteger reference = ref lhs; int length = lhs._length; ref BigInteger reference2 = ref rhs; int length2 = rhs._length; if (length < length2) { reference = ref rhs; length = rhs._length; reference2 = ref lhs; length2 = lhs._length; } int num = (result._length = length2 + length); BufferEx.ZeroMemory((byte*)result.GetBlocksPointer(), (uint)(num * 4)); int num2 = 0; int num3 = 0; while (num2 < length2) { if (reference2._blocks[num2] != 0) { int num4 = 0; int num5 = num3; ulong num6 = 0uL; do { ulong num7 = (ulong)(result._blocks[num5] + (long)reference2._blocks[num2] * (long)reference._blocks[num4]) + num6; num6 = num7 >> 32; result._blocks[num5] = (uint)num7; num5++; num4++; } while (num4 < length); result._blocks[num5] = (uint)num6; } num2++; num3++; } if (num > 0 && result._blocks[num - 1] == 0) { result._length--; } } public unsafe static void Pow2(uint exponent, out BigInteger result) { uint remainder; uint num = DivRem32(exponent, out remainder); result._length = (int)(num + 1); if (num != 0) { BufferEx.ZeroMemory((byte*)result.GetBlocksPointer(), num * 4); } result._blocks[num] = (uint)(1 << (int)remainder); } public unsafe static void Pow10(uint exponent, out BigInteger result) { SetUInt32(out var result2, s_Pow10UInt32Table[exponent & 7]); ref BigInteger reference = ref result2; SetZero(out var result3); ref BigInteger reference2 = ref result3; exponent >>= 3; uint num = 0u; while (exponent != 0) { if ((exponent & (true ? 1u : 0u)) != 0) { fixed (uint* ptr = &s_Pow10BigNumTable[s_Pow10BigNumTableIndices[num]]) { Multiply(ref reference, ref *(BigInteger*)ptr, out reference2); } ref BigInteger reference3 = ref reference2; reference2 = ref reference; reference = ref reference3; } num++; exponent >>= 1; } SetValue(out result, ref reference); } private unsafe static uint AddDivisor(ref BigInteger lhs, int lhsStartIndex, ref BigInteger rhs) { int length = rhs._length; ulong num = 0uL; for (int i = 0; i < length; i++) { ref uint reference = ref lhs._blocks[lhsStartIndex + i]; ulong num2 = reference + num + rhs._blocks[i]; reference = (uint)num2; num = num2 >> 32; } return (uint)num; } private static bool DivideGuessTooBig(ulong q, ulong valHi, uint valLo, uint divHi, uint divLo) { ulong num = divHi * q; ulong num2 = divLo * q; num += num2 >> 32; num2 &= 0xFFFFFFFFu; if (num < valHi) { return false; } if (num > valHi) { return true; } if (num2 < valLo) { return false; } if (num2 > valLo) { return true; } return false; } private unsafe static uint SubtractDivisor(ref BigInteger lhs, int lhsStartIndex, ref BigInteger rhs, ulong q) { int length = rhs._length; ulong num = 0uL; for (int i = 0; i < length; i++) { num += rhs._blocks[i] * q; uint num2 = (uint)num; num >>= 32; ref uint reference = ref lhs._blocks[lhsStartIndex + i]; if (reference < num2) { num++; } reference -= num2; } return (uint)num; } public unsafe void Add(uint value) { int length = _length; if (length == 0) { SetUInt32(out this, value); return; } _blocks[0] += value; if (_blocks[0] >= value) { return; } for (int i = 1; i < length; i++) { ref uint reference = ref _blocks[i]; reference++; if (_blocks[i] != 0) { return; } } _blocks[length] = 1u; _length = length + 1; } public unsafe uint GetBlock(uint index) { return _blocks[index]; } public int GetLength() { return _length; } public unsafe bool IsOne() { if (_length == 1) { return _blocks[0] == 1; } return false; } public bool IsZero() { return _length == 0; } public void Multiply(uint value) { Multiply(ref this, value, out this); } public void Multiply(ref BigInteger value) { SetValue(out var result, ref this); Multiply(ref result, ref value, out this); } public unsafe void Multiply10() { if (!IsZero()) { int i = 0; int length = _length; ulong num = 0uL; for (; i < length; i++) { ulong num2 = _blocks[i]; ulong num3 = (num2 << 3) + (num2 << 1) + num; num = num3 >> 32; _blocks[i] = (uint)num3; } if (num != 0L) { _blocks[i] = (uint)num; _length++; } } } public unsafe void MultiplyPow10(uint exponent) { if (!IsZero()) { Pow10(exponent, out var result); if (result._length == 1) { Multiply(result._blocks[0]); } else { Multiply(ref result); } } } public unsafe static void SetUInt32(out BigInteger result, uint value) { if (value == 0) { SetZero(out result); return; } result._blocks[0] = value; result._length = 1; } public unsafe static void SetUInt64(out BigInteger result, ulong value) { if (value <= uint.MaxValue) { SetUInt32(out result, (uint)value); return; } result._blocks[0] = (uint)value; result._blocks[1] = (uint)(value >> 32); result._length = 2; } public unsafe static void SetValue(out BigInteger result, ref BigInteger value) { BufferEx.Memcpy(len: (result._length = value._length) * 4, dest: (byte*)result.GetBlocksPointer(), src: (byte*)value.GetBlocksPointer()); } public static void SetZero(out BigInteger result) { result._length = 0; } public unsafe void ShiftLeft(uint shift) { int length = _length; if (length == 0 || shift == 0) { return; } uint remainder; uint num = DivRem32(shift, out remainder); int num2 = length - 1; int num3 = num2 + (int)num; if (remainder == 0) { while (num2 >= 0) { _blocks[num3] = _blocks[num2]; num2--; num3--; } _length += (int)num; BufferEx.ZeroMemory((byte*)GetBlocksPointer(), num * 4); return; } num3++; _length = num3 + 1; uint num4 = 32 - remainder; uint num5 = 0u; uint num6 = _blocks[num2]; uint num7 = num6 >> (int)num4; while (num2 > 0) { _blocks[num3] = num5 | num7; num5 = num6 << (int)remainder; num2--; num3--; num6 = _blocks[num2]; num7 = num6 >> (int)num4; } _blocks[num3] = num5 | num7; _blocks[num3 - 1] = num6 << (int)remainder; BufferEx.ZeroMemory((byte*)GetBlocksPointer(), num * 4); if (_blocks[_length - 1] == 0) { _length--; } } public unsafe ulong ToUInt64() { if (_length > 1) { return ((ulong)_blocks[1] << 32) + _blocks[0]; } if (_length > 0) { return _blocks[0]; } return 0uL; } private unsafe uint* GetBlocksPointer() { return (uint*)Unsafe.AsPointer(ref _blocks[0]); } private static uint DivRem32(uint value, out uint remainder) { remainder = value & 0x1Fu; return value >> 5; } } internal readonly ref struct DiyFp { public const int DoubleImplicitBitIndex = 52; public const int SingleImplicitBitIndex = 23; public const int SignificandSize = 64; public readonly ulong f; public readonly int e; public static DiyFp CreateAndGetBoundaries(double value, out DiyFp mMinus, out DiyFp mPlus) { DiyFp result = new DiyFp(value); result.GetBoundaries(52, out mMinus, out mPlus); return result; } public static DiyFp CreateAndGetBoundaries(float value, out DiyFp mMinus, out DiyFp mPlus) { DiyFp result = new DiyFp(value); result.GetBoundaries(23, out mMinus, out mPlus); return result; } public DiyFp(double value) { f = ExtractFractionAndBiasedExponent(value, out e); } public DiyFp(float value) { f = ExtractFractionAndBiasedExponent(value, out e); } public DiyFp(ulong f, int e) { this.f = f; this.e = e; } public DiyFp Multiply(in DiyFp other) { int num = (int)(f >> 32); uint num2 = (uint)f; uint num3 = (uint)(other.f >> 32); uint num4 = (uint)other.f; ulong num5 = (ulong)(uint)num * (ulong)num3; ulong num6 = (ulong)num2 * (ulong)num3; ulong num7 = (ulong)(uint)num * (ulong)num4; ulong num8 = (ulong)(((long)num2 * (long)num4 >>> 32) + (uint)num7 + (uint)num6); num8 += 2147483648u; return new DiyFp(num5 + (num7 >> 32) + (num6 >> 32) + (num8 >> 32), e + other.e + 64); } public DiyFp Normalize() { int num = BitOperations.LeadingZeroCount(f); return new DiyFp(f << num, e - num); } public DiyFp Subtract(in DiyFp other) { return new DiyFp(f - other.f, e); } private void GetBoundaries(int implicitBitIndex, out DiyFp mMinus, out DiyFp mPlus) { mPlus = new DiyFp((f << 1) + 1, e - 1).Normalize(); if (f == (ulong)(1L << implicitBitIndex)) { mMinus = new DiyFp((f << 2) - 1, e - 2); } else { mMinus = new DiyFp((f << 1) - 1, e - 1); } mMinus = new DiyFp(mMinus.f << mMinus.e - mPlus.e, mPlus.e); } } internal static class Grisu3 { private const int CachedPowersDecimalExponentDistance = 8; private const int CachedPowersMinDecimalExponent = -348; private const int CachedPowersPowerMaxDecimalExponent = 340; private const int CachedPowersOffset = 348; private const double D1Log210 = 0.3010299956639812; private const int MaximalTargetExponent = -32; private const int MinimalTargetExponent = -60; private static readonly short[] s_CachedPowersBinaryExponent = new short[87] { -1220, -1193, -1166, -1140, -1113, -1087, -1060, -1034, -1007, -980, -954, -927, -901, -874, -847, -821, -794, -768, -741, -715, -688, -661, -635, -608, -582, -555, -529, -502, -475, -449, -422, -396, -369, -343, -316, -289, -263, -236, -210, -183, -157, -130, -103, -77, -50, -24, 3, 30, 56, 83, 109, 136, 162, 189, 216, 242, 269, 295, 322, 348, 375, 402, 428, 455, 481, 508, 534, 561, 588, 614, 641, 667, 694, 720, 747, 774, 800, 827, 853, 880, 907, 933, 960, 986, 1013, 1039, 1066 }; private static readonly short[] s_CachedPowersDecimalExponent = new short[87] { -348, -340, -332, -324, -316, -308, -300, -292, -284, -276, -268, -260, -252, -244, -236, -228, -220, -212, -204, -196, -188, -180, -172, -164, -156, -148, -140, -132, -124, -116, -108, -100, -92, -84, -76, -68, -60, -52, -44, -36, -28, -20, -12, -4, 4, 12, 20, 28, 36, 44, 52, 60, 68, 76, 84, 92, 100, 108, 116, 124, 132, 140, 148, 156, 164, 172, 180, 188, 196, 204, 212, 220, 228, 236, 244, 252, 260, 268, 276, 284, 292, 300, 308, 316, 324, 332, 340 }; private static readonly ulong[] s_CachedPowersSignificand = new ulong[87] { 18054884314459144840uL, 13451937075301367670uL, 10022474136428063862uL, 14934650266808366570uL, 11127181549972568877uL, 16580792590934885855uL, 12353653155963782858uL, 18408377700990114895uL, 13715310171984221708uL, 10218702384817765436uL, 15227053142812498563uL, 11345038669416679861uL, 16905424996341287883uL, 12595523146049147757uL, 9384396036005875287uL, 13983839803942852151uL, 10418772551374772303uL, 15525180923007089351uL, 11567161174868858868uL, 17236413322193710309uL, 12842128665889583758uL, 9568131466127621947uL, 14257626930069360058uL, 10622759856335341974uL, 15829145694278690180uL, 11793632577567316726uL, 17573882009934360870uL, 13093562431584567480uL, 9755464219737475723uL, 14536774485912137811uL, 10830740992659433045uL, 16139061738043178685uL, 12024538023802026127uL, 17917957937422433684uL, 13349918974505688015uL, 9946464728195732843uL, 14821387422376473014uL, 11042794154864902060uL, 16455045573212060422uL, 12259964326927110867uL, 18268770466636286478uL, 13611294676837538539uL, 10141204801825835212uL, 15111572745182864684uL, 11258999068426240000uL, 16777216000000000000uL, 12500000000000000000uL, 9313225746154785156uL, 13877787807814456755uL, 10339757656912845936uL, 15407439555097886824uL, 11479437019748901445uL, 17105694144590052135uL, 12744735289059618216uL, 9495567745759798747uL, 14149498560666738074uL, 10542197943230523224uL, 15709099088952724970uL, 11704190886730495818uL, 17440603504673385349uL, 12994262207056124023uL, 9681479787123295682uL, 14426529090290212157uL, 10748601772107342003uL, 16016664761464807395uL, 11933345169920330789uL, 17782069995880619868uL, 13248674568444952270uL, 9871031767461413346uL, 14708983551653345445uL, 10959046745042015199uL, 16330252207878254650uL, 12166986024289022870uL, 18130221999122236476uL, 13508068024458167312uL, 10064294952495520794uL, 14996968138956309548uL, 11173611982879273257uL, 16649979327439178909uL, 12405201291620119593uL, 9242595204427927429uL, 13772540099066387757uL, 10261342003245940623uL, 15290591125556738113uL, 11392378155556871081uL, 16975966327722178521uL, 12648080533535911531uL }; private static readonly uint[] s_SmallPowersOfTen = new uint[10] { 1u, 10u, 100u, 1000u, 10000u, 100000u, 1000000u, 10000000u, 100000000u, 1000000000u }; [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsNegative(double d) { return BitConverter.DoubleToInt64Bits(d) < 0; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsNegativeInfinity(float f) { return f == float.NegativeInfinity; } public static bool TryRunDouble(double value, int requestedDigits, ref NumberBuffer number) { double value2 = (IsNegative(value) ? (0.0 - value) : value); DiyFp diyFp; bool flag; int length; int decimalExponent; if (requestedDigits == -1) { diyFp = DiyFp.CreateAndGetBoundaries(value2, out var mMinus, out var mPlus); DiyFp w = diyFp.Normalize(); flag = TryRunShortest(in mMinus, in w, in mPlus, number.Digits, out length, out decimalExponent); } else { diyFp = new DiyFp(value2); DiyFp w2 = diyFp.Normalize(); flag = TryRunCounted(in w2, requestedDigits, number.Digits, out length, out decimalExponent); } if (flag) { number.Scale = length + decimalExponent; number.Digits[length] = 0; number.DigitsCount = length; } return flag; } public static bool TryRunSingle(float value, int requestedDigits, ref NumberBuffer number) { float value2 = (IsNegative(value) ? (0f - value) : value); DiyFp diyFp; bool flag; int length; int decimalExponent; if (requestedDigits == -1) { diyFp = DiyFp.CreateAndGetBoundaries(value2, out var mMinus, out var mPlus); DiyFp w = diyFp.Normalize(); flag = TryRunShortest(in mMinus, in w, in mPlus, number.Digits, out length, out decimalExponent); } else { diyFp = new DiyFp(value2); DiyFp w2 = diyFp.Normalize(); flag = TryRunCounted(in w2, requestedDigits, number.Digits, out length, out decimalExponent); } if (flag) { number.Scale = length + decimalExponent; number.Digits[length] = 0; number.DigitsCount = length; } return flag; } private static bool TryRunCounted(in DiyFp w, int requestedDigits, Span<byte> buffer, out int length, out int decimalExponent) { int minExponent = -60 - (w.e + 64); int maxExponent = -32 - (w.e + 64); int decimalExponent2; DiyFp other = GetCachedPowerForBinaryExponentRange(minExponent, maxExponent, out decimalExponent2); DiyFp w2 = w.Multiply(in other); int kappa; bool result = TryDigitGenCounted(in w2, requestedDigits, buffer, out length, out kappa); decimalExponent = -decimalExponent2 + kappa; return result; } private static bool TryRunShortest(in DiyFp boundaryMinus, in DiyFp w, in DiyFp boundaryPlus, Span<byte> buffer, out int length, out int decimalExponent) { int minExponent = -60 - (w.e + 64); int maxExponent = -32 - (w.e + 64); int decimalExponent2; DiyFp other = GetCachedPowerForBinaryExponentRange(minExponent, maxExponent, out decimalExponent2); DiyFp w2 = w.Multiply(in other); DiyFp low = boundaryMinus.Multiply(in other); DiyFp high = boundaryPlus.Multiply(in other); int kappa; bool result = TryDigitGenShortest(in low, in w2, in high, buffer, out length, out kappa); decimalExponent = -decimalExponent2 + kappa; return result; } private static uint BiggestPowerTen(uint number, int numberBits, out int exponentPlusOne) { int num = (numberBits + 1) * 1233 >> 12; uint num2 = s_SmallPowersOfTen[num]; if (number < num2) { num--; num2 = s_SmallPowersOfTen[num]; } exponentPlusOne = num + 1; return num2; } private static bool TryDigitGenCounted(in DiyFp w, int requestedDigits, Span<byte> buffer, out int length, out int kappa) { ulong num = 1uL; DiyFp diyFp = new DiyFp((ulong)(1L << -w.e), w.e); uint result = (uint)(w.f >> -diyFp.e); ulong num2 = w.f & (diyFp.f - 1); if (num2 == 0L && (requestedDigits >= 11 || result < s_SmallPowersOfTen[requestedDigits - 1])) { length = 0; kappa = 0; return false; } uint num3 = BiggestPowerTen(result, 64 - -diyFp.e, out kappa); length = 0; while (kappa > 0) { uint num4 = MathEx.DivRem(result, num3, out result); buffer[length] = (byte)(48 + num4); length++; requestedDigits--; kappa--; if (requestedDigits == 0) { break; } num3 /= 10; } if (requestedDigits == 0) { ulong rest = ((ulong)result << -diyFp.e) + num2; return TryRoundWeedCounted(buffer, length, rest, (ulong)num3 << -diyFp.e, num, ref kappa); } while (requestedDigits > 0 && num2 > num) { num2 *= 10; num *= 10; uint num5 = (uint)(num2 >> -diyFp.e); buffer[length] = (byte)(48 + num5); length++; requestedDigits--; kappa--; num2 &= diyFp.f - 1; } if (requestedDigits != 0) { buffer[0] = 0; length = 0; kappa = 0; return false; } return TryRoundWeedCounted(buffer, length, num2, diyFp.f, num, ref kappa); } private static bool TryDigitGenShortest(in DiyFp low, in DiyFp w, in DiyFp high, Span<byte> buffer, out int length, out int kappa) { ulong num = 1uL; DiyFp other = new DiyFp(low.f - num, low.e); DiyFp diyFp = new DiyFp(high.f + num, high.e); DiyFp diyFp2 = diyFp.Subtract(in other); DiyFp diyFp3 = new DiyFp((ulong)(1L << -w.e), w.e); uint result = (uint)(diyFp.f >> -diyFp3.e); ulong num2 = diyFp.f & (diyFp3.f - 1); uint num3 = BiggestPowerTen(result, 64 - -diyFp3.e, out kappa); length = 0; while (kappa > 0) { uint num4 = MathEx.DivRem(result, num3, out result); buffer[length] = (byte)(48 + num4); length++; kappa--; ulong num5 = ((ulong)result << -diyFp3.e) + num2; if (num5 < diyFp2.f) { return TryRoundWeedShortest(buffer, length, diyFp.Subtract(in w).f, diyFp2.f, num5, (ulong)num3 << -diyFp3.e, num); } num3 /= 10; } do { num2 *= 10; num *= 10; diyFp2 = new DiyFp(diyFp2.f * 10, diyFp2.e); uint num6 = (uint)(num2 >> -diyFp3.e); buffer[length] = (byte)(48 + num6); length++; kappa--; num2 &= diyFp3.f - 1; } while (num2 >= diyFp2.f); return TryRoundWeedShortest(buffer, length, diyFp.Subtract(in w).f * num, diyFp2.f, num2, diyFp3.f, num); } private static DiyFp GetCachedPowerForBinaryExponentRange(int minExponent, int maxExponent, out int decimalExponent) { double num = Math.Ceiling((double)(minExponent + 64 - 1) * 0.3010299956639812); int num2 = (348 + (int)num - 1) / 8 + 1; decimalExponent = s_CachedPowersDecimalExponent[num2]; return new DiyFp(s_CachedPowersSignificand[num2], s_CachedPowersBinaryExponent[num2]); } private static bool TryRoundWeedCounted(Span<byte> buffer, int length, ulong rest, ulong tenKappa, ulong unit, ref int kappa) { if (unit >= tenKappa || tenKappa - unit <= unit) { return false; } if (tenKappa - rest > rest && tenKappa - 2 * rest >= 2 * unit) { return true; } if (rest > unit && (tenKappa <= rest - unit || tenKappa - (rest - unit) <= rest - unit)) { buffer[length - 1]++; int num = length - 1; while (num > 0 && buffer[num] == 58) { buffer[num] = 48; buffer[num - 1]++; num--; } if (buffer[0] == 58) { buffer[0] = 49; kappa++; } return true; } return false; } private static bool TryRoundWeedShortest(Span<byte> buffer, int length, ulong distanceTooHighW, ulong unsafeInterval, ulong rest, ulong tenKappa, ulong unit) { ulong num = distanceTooHighW - unit; ulong num2 = distanceTooHighW + unit; while (rest < num && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num || num - rest >= rest + tenKappa - num)) { buffer[length - 1]--; rest += tenKappa; } if (rest < num2 && unsafeInterval - rest >= tenKappa && (rest + tenKappa < num2 || num2 - rest > rest + tenKappa - num2)) { return false; } if (2 * unit <= rest) { return rest <= unsafeInterval - 4 * unit; } return false; } } internal ref struct NumberBuffer { public int DigitsCount; public int Scale; public bool IsNegative; public bool HasNonZeroTail; public NumberBufferKind Kind; public Span<byte> Digits; public unsafe NumberBuffer(NumberBufferKind kind, byte* digits, int digitsLength) { DigitsCount = 0; Scale = 0; IsNegative = false; HasNonZeroTail = false; Kind = kind; Digits = new Span<byte>(digits, digitsLength); Digits[0] = 0; } [Conditional("DEBUG")] public void CheckConsistency() { } public unsafe byte* GetDigitsPointer() { return (byte*)Unsafe.AsPointer(ref Digits[0]); } public override string ToString() { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append('['); stringBuilder.Append('"'); for (int i = 0; i < Digits.Length; i++) { byte b = Digits[i]; if (b == 0) { break; } stringBuilder.Append((char)b); } stringBuilder.Append('"'); stringBuilder.Append(", Length = ").Append(DigitsCount); stringBuilder.Append(", Scale = ").Append(Scale); stringBuilder.Append(", IsNegative = ").Append(IsNegative); stringBuilder.Append(", HasNonZeroTail = ").Append(HasNonZeroTail); stringBuilder.Append(", Kind = ").Append(Kind); stringBuilder.Append(']'); return stringBuilder.ToString(); } } internal enum NumberBufferKind : byte { Unknown, Integer, Decimal, FloatingPoint } public readonly struct FloatingPointInfo { public static readonly FloatingPointInfo Double = new FloatingPointInfo(52, 11, 1023, 1023, 9218868437227405312uL); public static readonly FloatingPointInfo Single = new FloatingPointInfo(23, 8, 127, 127, 2139095040uL); public ulong ZeroBits { get; } public ulong InfinityBits { get; } public ulong NormalMantissaMask { get; } public ulong DenormalMantissaMask { get; } public int MinBinaryExponent { get; } public int MaxBinaryExponent { get; } public int ExponentBias { get; } public int OverflowDecimalExponent { get; } public ushort NormalMantissaBits { get; } public ushort DenormalMantissaBits { get; } public ushort ExponentBits { get; } public FloatingPointInfo(ushort denormalMantissaBits, ushort exponentBits, int maxBinaryExponent, int exponentBias, ulong infinityBits) { ExponentBits = exponentBits; DenormalMantissaBits = denormalMantissaBits; NormalMantissaBits = (ushort)(denormalMantissaBits + 1); OverflowDecimalExponent = (maxBinaryExponent + 2 * NormalMantissaBits) / 3; ExponentBias = exponentBias; MaxBinaryExponent = maxBinaryExponent; MinBinaryExponent = 1 - maxBinaryExponent; DenormalMantissaMask = (ulong)((1L << (int)denormalMantissaBits) - 1); NormalMantissaMask = (ulong)((1L << (int)NormalMantissaBits) - 1); InfinityBits = infinityBits; ZeroBits = 0uL; } } internal enum ParsingStatus { OK, Failed, Overflow } internal const int DecimalPrecision = 29; private const int SinglePrecision = 9; private const int DoublePrecision = 17; private const int SinglePrecisionCustomFormat = 7; private const int DoublePrecisionCustomFormat = 15; private const int DefaultPrecisionExponentialFormat = 6; private const int MaxUInt32DecDigits = 10; private const int CharStackBufferSize = 32; private const string PosNumberFormat = "#"; private static readonly string[] s_singleDigitStringCache = new string[10] { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" }; private static readonly string[] s_posCurrencyFormats = new string[4] { "$#", "#$", "$ #", "# $" }; private static readonly string[] s_negCurrencyFormats = new string[16] { "($#)", "-$#", "$-#", "$#-", "(#$)", "-#$", "#-$", "#$-", "-# $", "-$ #", "# $-", "$ #-", "$ -#", "#- $", "($ #)", "(# $)" }; private static readonly string[] s_posPercentFormats = new string[4] { "# %", "#%", "%#", "% #" }; private static readonly string[] s_negPercentFormats = new string[12] { "-# %", "-#%", "-%#", "%-#", "%#-", "#-%", "#%-", "-% #", "# %-", "% #-", "% -#", "#- %" }; private static readonly string[] s_negNumberFormats = new string[5] { "(#)", "-#", "- #", "#-", "# -" }; internal const int DecimalNumberBufferLength = 31; internal const int DoubleNumberBufferLength = 769; internal const int Int32NumberBufferLength = 11; internal const int Int64NumberBufferLength = 20; internal const int SingleNumberBufferLength = 114; internal const int UInt32NumberBufferLength = 11; internal const int UInt64NumberBufferLength = 21; private static readonly float[] s_Pow10SingleTable = new float[11] { 1f, 10f, 100f, 1000f, 10000f, 100000f, 1000000f, 10000000f, 100000000f, 1E+09f, 1E+10f }; private static readonly double[] s_Pow10DoubleTable = new double[23] { 1.0, 10.0, 100.0, 1000.0, 10000.0, 100000.0, 1000000.0, 10000000.0, 100000000.0, 1000000000.0, 10000000000.0, 100000000000.0, 1000000000000.0, 10000000000000.0, 100000000000000.0, 1000000000000000.0, 10000000000000000.0, 1E+17, 1E+18, 1E+19, 1E+20, 1E+21, 1E+22 }; private const int Int32Precision = 10; private const int UInt32Precision = 10; private const int Int64Precision = 19; private const int UInt64Precision = 20; private const int DoubleMaxExponent = 309; private const int DoubleMinExponent = -324; private const int FloatingPointMaxExponent = 309; private const int FloatingPointMinExponent = -324; private const int SingleMaxExponent = 39; private const int SingleMinExponent = -45; internal static ReadOnlySpan<byte> CharToHexLookup => new byte[103] { 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 255, 255, 255, 255, 255, 255, 255, 10, 11, 12, 13, 14, 15, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 10, 11, 12, 13, 14, 15 }; [MethodImpl(MethodImplOptions.AggressiveInlining)] private static bool IsNegative(double d) { return BitConverter.DoubleToInt64Bits(d) < 0; } [MethodImpl(MethodImplOptions.AggressiveInlining)] public static bool IsNegativeInfinity(float f) { return f == float.NegativeInfinity; } public static void Dragon4Double(double value, int cutoffNumber, bool isSignificantDigits, ref NumberBuffer number) { IsNegative(value); int exponent; ulong num = ExtractFractionAndBiasedExponent(value, out exponent); bool hasUnequalMargins = false; uint mantissaHighBitIdx; if (num >> 52 != 0L) { mantissaHighBitIdx = 52u; hasUnequalMargins = num == 4503599627370496L; } else { mantissaHighBitIdx = (uint)BitOperations.Log2(num); } int decimalExponent; int num2 = (int)Dragon4(num, exponent, mantissaHighBitIdx, hasUnequalMargins, cutoffNumber, isSignificantDigits, number.Digits, out decimalExponent); number.Scale = decimalExponent + 1; number.Digits[num2] = 0; number.DigitsCount = num2; } public static void Dragon4Single(float value, int cutoffNumber, bool isSignificantDigits, ref NumberBuffer number) { IsNegative(value); int exponent; uint num = ExtractFractionAndBiasedExponent(value, out exponent); bool hasUnequalMargins = false; uint mantissaHighBitIdx; if (num >> 23 != 0) { mantissaHighBitIdx = 23u; hasUnequalMargins = num == 8388608; } else { mantissaHighBitIdx = (uint)BitOperations.Log2(num); } int decimalExponent; int num2 = (int)Dragon4(num, exponent, mantissaHighBitIdx, hasUnequalMargins, cutoffNumber, isSignificantDigits, number.Digits, out decimalExponent); number.Scale = decimalExponent + 1; number.Digits[num2] = 0; number.DigitsCount = num2; } private unsafe static uint Dragon4(ulong mantissa, int exponent, uint mantissaHighBitIdx, bool hasUnequalMargins, int cutoffNumber, bool isSignificantDigits, Span<byte> buffer, out int decimalExponent) { int num = 0; BigInteger result; BigInteger result2; BigInteger result3; BigInteger* ptr; if (hasUnequalMargins) { BigInteger result4; if (exponent > 0) { BigInteger.SetUInt64(out result, 4 * mantissa); result.ShiftLeft((uint)exponent); BigInteger.SetUInt32(out result2, 4u); BigInteger.Pow2((uint)exponent, out result3); BigInteger.Pow2((uint)(exponent + 1), out result4); } else { BigInteger.SetUInt64(out result, 4 * mantissa); BigInteger.Pow2((uint)(-exponent + 2), out result2); BigInteger.SetUInt32(out result3, 1u); BigInteger.SetUInt32(out result4, 2u); } ptr = &result4; } else { if (exponent > 0) { BigInteger.SetUInt64(out result, 2 * mantissa); result.ShiftLeft((uint)exponent); BigInteger.SetUInt32(out result2, 2u); BigInteger.Pow2((uint)exponent, out result3); } else { BigInteger.SetUInt64(out result, 2 * mantissa); BigInteger.Pow2((uint)(-exponent + 1), out result2); BigInteger.SetUInt32(out result3, 1u); } ptr = &result3; } int num2 = (int)Math.Ceiling((double)((int)mantissaHighBitIdx + exponent) * 0.3010299956639812 - 0.69); if (num2 > 0) { result2.MultiplyPow10((uint)num2); } else if (num2 < 0) { BigInteger.Pow10((uint)(-num2), out var result5); result.Multiply(ref result5); result3.Multiply(ref result5); if (ptr != &result3) { BigInteger.Multiply(ref result3, 2u, out *ptr); } } bool flag = mantissa % 2 == 0; bool flag2 = false; if (cutoffNumber == -1) { BigInteger.Add(ref result, ref *ptr, out var result6); int num3 = BigInteger.Compare(ref result6, ref result2); flag2 = (flag ? (num3 >= 0) : (num3 > 0)); } else { flag2 = BigInteger.Compare(ref result, ref result2) >= 0; } if (flag2) { num2++; } else { result.Multiply10(); result3.Multiply10(); if (ptr != &result3) { BigInteger.Multiply(ref result3, 2u, out *ptr); } } int num4 = num2 - buffer.Length; if (cutoffNumber != -1) { int num5 = 0; num5 = ((!isSignificantDigits) ? (-cutoffNumber) : (num2 - cutoffNumber)); if (num5 > num4) { num4 = num5; } } num2 = (decimalExponent = num2 - 1); uint block = result2.GetBlock((uint)(result2.GetLength() - 1)); if (block < 8 || block > 429496729) { uint num6 = (uint)BitOperations.Log2(block); uint shift = (59 - num6) % 32; result2.ShiftLeft(shift); result.ShiftLeft(shift); result3.ShiftLeft(shift); if (ptr != &result3) { BigInteger.Multiply(ref result3, 2u, out *ptr); } } bool flag3; bool flag4; uint num7; if (cutoffNumber == -1) { while (true) { num7 = BigInteger.HeuristicDivide(ref result, ref result2); BigInteger.Add(ref result, ref *ptr, out var result7); int num8 = BigInteger.Compare(ref result, ref result3); int num9 = BigInteger.Compare(ref result7, ref result2); if (flag) { flag3 = num8 <= 0; flag4 = num9 >= 0; } else { flag3 = num8 < 0; flag4 = num9 > 0; } if (flag3 || flag4 || num2 == num4) { break; } buffer[num] = (byte)(48 + num7); num++; result.Multiply10(); result3.Multiply10(); if (ptr != &result3) { BigInteger.Multiply(ref result3, 2u, out *ptr); } num2--; } } else { if (num2 < num4) { num7 = BigInteger.HeuristicDivide(ref result, ref result2); if (num7 > 5 || (num7 == 5 && !result.IsZero())) { decimalExponent++; num7 = 1u; } buffer[num] = (byte)(48 + num7); return (uint)(num + 1); } flag3 = false; flag4 = false; while (true) { num7 = BigInteger.HeuristicDivide(ref result, ref result2); if (result.IsZero() || num2 <= num4) { break; } buffer[num] = (byte)(48 + num7); num++; result.Multiply10(); num2--; } } bool flag5 = flag3; if (flag3 == flag4) { result.ShiftLeft(1u); int num10 = BigInteger.Compare(ref result, ref result2); flag5 = num10 < 0; if (num10 == 0) { flag5 = (num7 & 1) == 0; } } if (flag5) { buffer[num] = (byte)(48 + num7); num++; } else if (num7 == 9) { while (true) { if (num == 0) { buffer[num] = 49; num++; decimalExponent++; break; } num--; if (buffer[num] != 57) { buffer[num]++; num++; break; } } } else { buffer[num] = (byte)(48 + num7 + 1); num++; } return (uint)num; } public unsafe static string FormatDecimal(decimal value, ReadOnlySpan<char> format, NumberFormatInfo info) { int digits; char c = ParseFormatSpecifier(format, out digits); byte* digits2 = stackalloc byte[31]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Decimal, digits2, 31); DecimalToNumber(ref value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, info); } else { NumberToStringFormat(ref sb, ref number, format, info); } return sb.ToString(); } public unsafe static bool TryFormatDecimal(decimal value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten) { int digits; char c = ParseFormatSpecifier(format, out digits); byte* digits2 = stackalloc byte[31]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Decimal, digits2, 31); DecimalToNumber(ref value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, info); } else { NumberToStringFormat(ref sb, ref number, format, info); } return sb.TryCopyTo(destination, out charsWritten); } internal unsafe static void DecimalToNumber(ref decimal d, ref NumberBuffer number) { byte* digitsPointer = number.GetDigitsPointer(); number.DigitsCount = 29; number.IsNegative = d.IsNegative(); byte* bufferEnd = digitsPointer + 29; while ((d.Mid() | d.High()) != 0) { bufferEnd = UInt32ToDecChars(bufferEnd, DecimalEx.DecDivMod1E9(ref d), 9); } bufferEnd = UInt32ToDecChars(bufferEnd, d.Low(), 0); int num = (number.DigitsCount = (int)(digitsPointer + 29 - bufferEnd)); number.Scale = num - d.Scale(); byte* digitsPointer2 = number.GetDigitsPointer(); while (--num >= 0) { *(digitsPointer2++) = *(bufferEnd++); } *digitsPointer2 = 0; } public static string FormatDouble(double value, string format, NumberFormatInfo info) { Span<char> initialBuffer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer); return FormatDouble(ref sb, value, format.AsSpan(), info) ?? sb.ToString(); } public static bool TryFormatDouble(double value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten) { Span<char> initialBuffer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer); string text = FormatDouble(ref sb, value, format, info); if (text == null) { return sb.TryCopyTo(destination, out charsWritten); } return TryCopyTo(text, destination, out charsWritten); } private static int GetFloatingPointMaxDigitsAndPrecision(char fmt, ref int precision, NumberFormatInfo info, out bool isSignificantDigits) { if (fmt == '\0') { isSignificantDigits = true; return precision; } int result = precision; switch (fmt) { case 'C': case 'c': if (precision == -1) { precision = info.CurrencyDecimalDigits; } isSignificantDigits = false; break; case 'E': case 'e': if (precision == -1) { precision = 6; } precision++; isSignificantDigits = true; break; case 'F': case 'N': case 'f': case 'n': if (precision == -1) { precision = info.NumberDecimalDigits; } isSignificantDigits = false; break; case 'G': case 'g': if (precision == 0) { precision = -1; } isSignificantDigits = true; break; case 'P': case 'p': if (precision == -1) { precision = info.PercentDecimalDigits; } precision += 2; isSignificantDigits = false; break; case 'R': case 'r': precision = -1; isSignificantDigits = true; break; default: throw new FormatException("SR.Argument_BadFormatSpecifier"); } return result; } private unsafe static string FormatDouble(ref System.Text.ValueStringBuilder sb, double value, ReadOnlySpan<char> format, NumberFormatInfo info) { if (!FloatEx.IsFinite(value)) { if (double.IsNaN(value)) { return info.NaNSymbol; } if (!FloatEx.IsNegative(value)) { return info.PositiveInfinitySymbol; } return info.NegativeInfinitySymbol; } int digits; char c = ParseFormatSpecifier(format, out digits); byte* digits2 = stackalloc byte[769]; if (c == '\0') { digits = 15; } NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits2, 769); number.IsNegative = FloatEx.IsNegative(value); bool isSignificantDigits; int nMaxDigits = GetFloatingPointMaxDigitsAndPrecision(c, ref digits, info, out isSignificantDigits); if (value != 0.0 && (!isSignificantDigits || !Grisu3.TryRunDouble(value, digits, ref number))) { Dragon4Double(value, digits, isSignificantDigits, ref number); } if (c != 0) { if (digits == -1) { nMaxDigits = Math.Max(number.DigitsCount, 17); } NumberToString(ref sb, ref number, c, nMaxDigits, info); } else { NumberToStringFormat(ref sb, ref number, format, info); } return null; } public static string FormatSingle(float value, string format, NumberFormatInfo info) { Span<char> initialBuffer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer); return FormatSingle(ref sb, value, format.AsSpan(), info) ?? sb.ToString(); } public static bool TryFormatSingle(float value, ReadOnlySpan<char> format, NumberFormatInfo info, Span<char> destination, out int charsWritten) { Span<char> initialBuffer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(initialBuffer); string text = FormatSingle(ref sb, value, format, info); if (text == null) { return sb.TryCopyTo(destination, out charsWritten); } return TryCopyTo(text, destination, out charsWritten); } private unsafe static string FormatSingle(ref System.Text.ValueStringBuilder sb, float value, ReadOnlySpan<char> format, NumberFormatInfo info) { if (!FloatEx.IsFinite(value)) { if (float.IsNaN(value)) { return info.NaNSymbol; } if (!FloatEx.IsNegative(value)) { return info.PositiveInfinitySymbol; } return info.NegativeInfinitySymbol; } int digits; char c = ParseFormatSpecifier(format, out digits); byte* digits2 = stackalloc byte[114]; if (c == '\0') { digits = 7; } NumberBuffer number = new NumberBuffer(NumberBufferKind.FloatingPoint, digits2, 114); number.IsNegative = FloatEx.IsNegative(value); bool isSignificantDigits; int nMaxDigits = GetFloatingPointMaxDigitsAndPrecision(c, ref digits, info, out isSignificantDigits); if (value != 0f && (!isSignificantDigits || !Grisu3.TryRunSingle(value, digits, ref number))) { Dragon4Single(value, digits, isSignificantDigits, ref number); } if (c != 0) { if (digits == -1) { nMaxDigits = Math.Max(number.DigitsCount, 9); } NumberToString(ref sb, ref number, c, nMaxDigits, info); } else { NumberToStringFormat(ref sb, ref number, format, info); } return null; } private static bool TryCopyTo(string source, Span<char> destination, out int charsWritten) { if (source.AsSpan().TryCopyTo(destination)) { charsWritten = source.Length; return true; } charsWritten = 0; return false; } public unsafe static string FormatInt32(int value, ReadOnlySpan<char> format, IFormatProvider provider) { if (value >= 0 && format.Length == 0) { return UInt32ToDecStr((uint)value, -1); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return Int32ToHexStr(value, (char)(c - 33), digits); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[11]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11); Int32ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.ToString(); } } } if (value < 0) { return NegativeInt32ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign); } return UInt32ToDecStr((uint)value, digits); } public unsafe static bool TryFormatInt32(int value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten) { if (value >= 0 && format.Length == 0) { return TryUInt32ToDecStr((uint)value, -1, destination, out charsWritten); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return TryInt32ToHexStr(value, (char)(c - 33), digits, destination, out charsWritten); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[11]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11); Int32ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.TryCopyTo(destination, out charsWritten); } } } if (value < 0) { return TryNegativeInt32ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten); } return TryUInt32ToDecStr((uint)value, digits, destination, out charsWritten); } public unsafe static string FormatUInt32(uint value, ReadOnlySpan<char> format, IFormatProvider provider) { if (format.Length == 0) { return UInt32ToDecStr(value, -1); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return Int32ToHexStr((int)value, (char)(c - 33), digits); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[11]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11); UInt32ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.ToString(); } } } return UInt32ToDecStr(value, digits); } public unsafe static bool TryFormatUInt32(uint value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten) { if (format.Length == 0) { return TryUInt32ToDecStr(value, -1, destination, out charsWritten); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return TryInt32ToHexStr((int)value, (char)(c - 33), digits, destination, out charsWritten); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[11]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 11); UInt32ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.TryCopyTo(destination, out charsWritten); } } } return TryUInt32ToDecStr(value, digits, destination, out charsWritten); } public unsafe static string FormatInt64(long value, ReadOnlySpan<char> format, IFormatProvider provider) { if (value >= 0 && format.Length == 0) { return UInt64ToDecStr((ulong)value, -1); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return Int64ToHexStr(value, (char)(c - 33), digits); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[20]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 20); Int64ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.ToString(); } } } if (value < 0) { return NegativeInt64ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign); } return UInt64ToDecStr((ulong)value, digits); } public unsafe static bool TryFormatInt64(long value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten) { if (value >= 0 && format.Length == 0) { return TryUInt64ToDecStr((ulong)value, -1, destination, out charsWritten); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return TryInt64ToHexStr(value, (char)(c - 33), digits, destination, out charsWritten); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[20]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 20); Int64ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.TryCopyTo(destination, out charsWritten); } } } if (value < 0) { return TryNegativeInt64ToDecStr(value, digits, NumberFormatInfo.GetInstance(provider).NegativeSign, destination, out charsWritten); } return TryUInt64ToDecStr((ulong)value, digits, destination, out charsWritten); } public unsafe static string FormatUInt64(ulong value, ReadOnlySpan<char> format, IFormatProvider provider) { if (format.Length == 0) { return UInt64ToDecStr(value, -1); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return Int64ToHexStr((long)value, (char)(c - 33), digits); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[21]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 21); UInt64ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.ToString(); } } } return UInt64ToDecStr(value, digits); } public unsafe static bool TryFormatUInt64(ulong value, ReadOnlySpan<char> format, IFormatProvider provider, Span<char> destination, out int charsWritten) { if (format.Length == 0) { return TryUInt64ToDecStr(value, -1, destination, out charsWritten); } int digits; char c = ParseFormatSpecifier(format, out digits); char c2 = (char)(c & 0xFFDFu); if (c2 != 'G' || digits >= 1) { switch (c2) { case 'D': break; case 'X': return TryInt64ToHexStr((long)value, (char)(c - 33), digits, destination, out charsWritten); default: { NumberFormatInfo instance = NumberFormatInfo.GetInstance(provider); byte* digits2 = stackalloc byte[21]; NumberBuffer number = new NumberBuffer(NumberBufferKind.Integer, digits2, 21); UInt64ToNumber(value, ref number); char* pointer = stackalloc char[32]; System.Text.ValueStringBuilder sb = new System.Text.ValueStringBuilder(new Span<char>(pointer, 32)); if (c != 0) { NumberToString(ref sb, ref number, c, digits, instance); } else { NumberToStringFormat(ref sb, ref number, format, instance); } return sb.TryCopyTo(destination, out charsWritten); } } } return TryUInt64ToDecStr(value, digits, destination, out charsWritten); } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe static void Int32ToNumber(int value, ref NumberBuffer number) { number.DigitsCount = 10; if (value >= 0) { number.IsNegative = false; } else { number.IsNegative = true; value = -value; } byte* digitsPointer = number.GetDigitsPointer(); byte* ptr = UInt32ToDecChars(digitsPointer + 10, (uint)value, 0); int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 10 - ptr))); byte* digitsPointer2 = number.GetDigitsPointer(); while (--num >= 0) { *(digitsPointer2++) = *(ptr++); } *digitsPointer2 = 0; } private unsafe static string NegativeInt32ToDecStr(int value, int digits, string sNegative) { if (digits < 1) { digits = 1; } int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length; string text = FastAllocateString(num); fixed (char* ptr = text) { char* ptr2 = UInt32ToDecChars(ptr + num, (uint)(-value), digits); for (int num2 = sNegative.Length - 1; num2 >= 0; num2--) { *(--ptr2) = sNegative[num2]; } } return text; } private unsafe static bool TryNegativeInt32ToDecStr(int value, int digits, string sNegative, Span<char> destination, out int charsWritten) { if (digits < 1) { digits = 1; } int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits((uint)(-value))) + sNegative.Length; if (num > destination.Length) { charsWritten = 0; return false; } charsWritten = num; fixed (char* ptr = &MemoryMarshal.GetReference(destination)) { char* ptr2 = UInt32ToDecChars(ptr + num, (uint)(-value), digits); for (int num2 = sNegative.Length - 1; num2 >= 0; num2--) { *(--ptr2) = sNegative[num2]; } } return true; } private unsafe static string Int32ToHexStr(int value, char hexBase, int digits) { if (digits < 1) { digits = 1; } int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((uint)value)); string text = FastAllocateString(num); fixed (char* ptr = text) { Int32ToHexChars(ptr + num, (uint)value, hexBase, digits); } return text; } private unsafe static bool TryInt32ToHexStr(int value, char hexBase, int digits, Span<char> destination, out int charsWritten) { if (digits < 1) { digits = 1; } int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((uint)value)); if (num > destination.Length) { charsWritten = 0; return false; } charsWritten = num; fixed (char* ptr = &MemoryMarshal.GetReference(destination)) { Int32ToHexChars(ptr + num, (uint)value, hexBase, digits); } return true; } private unsafe static char* Int32ToHexChars(char* buffer, uint value, int hexBase, int digits) { while (--digits >= 0 || value != 0) { byte b = (byte)(value & 0xFu); *(--buffer) = (char)(b + ((b < 10) ? 48 : hexBase)); value >>= 4; } return buffer; } [MethodImpl(MethodImplOptions.AggressiveInlining)] private unsafe static void UInt32ToNumber(uint value, ref NumberBuffer number) { number.DigitsCount = 10; number.IsNegative = false; byte* digitsPointer = number.GetDigitsPointer(); byte* ptr = UInt32ToDecChars(digitsPointer + 10, value, 0); int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 10 - ptr))); byte* digitsPointer2 = number.GetDigitsPointer(); while (--num >= 0) { *(digitsPointer2++) = *(ptr++); } *digitsPointer2 = 0; } internal unsafe static byte* UInt32ToDecChars(byte* bufferEnd, uint value, int digits) { while (--digits >= 0 || value != 0) { value = MathEx.DivRem(value, 10u, out var result); *(--bufferEnd) = (byte)(result + 48); } return bufferEnd; } internal unsafe static char* UInt32ToDecChars(char* bufferEnd, uint value, int digits) { while (--digits >= 0 || value != 0) { value = MathEx.DivRem(value, 10u, out var result); *(--bufferEnd) = (char)(result + 48); } return bufferEnd; } internal unsafe static string UInt32ToDecStr(uint value, int digits) { int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value)); if (num == 1) { return s_singleDigitStringCache[value]; } string text = FastAllocateString(num); fixed (char* ptr = text) { char* ptr2 = ptr + num; if (digits <= 1) { do { value = MathEx.DivRem(value, 10u, out var result); *(--ptr2) = (char)(result + 48); } while (value != 0); } else { ptr2 = UInt32ToDecChars(ptr2, value, digits); } } return text; } private unsafe static bool TryUInt32ToDecStr(uint value, int digits, Span<char> destination, out int charsWritten) { int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value)); if (num > destination.Length) { charsWritten = 0; return false; } charsWritten = num; fixed (char* ptr = &MemoryMarshal.GetReference(destination)) { char* ptr2 = ptr + num; if (digits <= 1) { do { value = MathEx.DivRem(value, 10u, out var result); *(--ptr2) = (char)(result + 48); } while (value != 0); } else { ptr2 = UInt32ToDecChars(ptr2, value, digits); } } return true; } private unsafe static void Int64ToNumber(long input, ref NumberBuffer number) { ulong value = (ulong)input; number.IsNegative = input < 0; number.DigitsCount = 19; if (number.IsNegative) { value = (ulong)(-input); } byte* digitsPointer = number.GetDigitsPointer(); byte* bufferEnd = digitsPointer + 19; while (High32(value) != 0) { bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9); } bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), 0); int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 19 - bufferEnd))); byte* digitsPointer2 = number.GetDigitsPointer(); while (--num >= 0) { *(digitsPointer2++) = *(bufferEnd++); } *digitsPointer2 = 0; } private unsafe static string NegativeInt64ToDecStr(long input, int digits, string sNegative) { if (digits < 1) { digits = 1; } ulong value = (ulong)(-input); int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value)) + sNegative.Length; string text = FastAllocateString(num); fixed (char* ptr = text) { char* bufferEnd = ptr + num; while (High32(value) != 0) { bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9); digits -= 9; } bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits); for (int num2 = sNegative.Length - 1; num2 >= 0; num2--) { *(--bufferEnd) = sNegative[num2]; } } return text; } private unsafe static bool TryNegativeInt64ToDecStr(long input, int digits, string sNegative, Span<char> destination, out int charsWritten) { if (digits < 1) { digits = 1; } ulong value = (ulong)(-input); int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits((ulong)(-input))) + sNegative.Length; if (num > destination.Length) { charsWritten = 0; return false; } charsWritten = num; fixed (char* ptr = &MemoryMarshal.GetReference(destination)) { char* bufferEnd = ptr + num; while (High32(value) != 0) { bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9); digits -= 9; } bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits); for (int num2 = sNegative.Length - 1; num2 >= 0; num2--) { *(--bufferEnd) = sNegative[num2]; } } return true; } private unsafe static string Int64ToHexStr(long value, char hexBase, int digits) { int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((ulong)value)); string text = FastAllocateString(num); fixed (char* ptr = text) { char* buffer = ptr + num; if (High32((ulong)value) != 0) { buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, 8); buffer = Int32ToHexChars(buffer, High32((ulong)value), hexBase, digits - 8); } else { buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, Math.Max(digits, 1)); } } return text; } private unsafe static bool TryInt64ToHexStr(long value, char hexBase, int digits, Span<char> destination, out int charsWritten) { int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountHexDigits((ulong)value)); if (num > destination.Length) { charsWritten = 0; return false; } charsWritten = num; fixed (char* ptr = &MemoryMarshal.GetReference(destination)) { char* buffer = ptr + num; if (High32((ulong)value) != 0) { buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, 8); buffer = Int32ToHexChars(buffer, High32((ulong)value), hexBase, digits - 8); } else { buffer = Int32ToHexChars(buffer, Low32((ulong)value), hexBase, Math.Max(digits, 1)); } } return true; } private unsafe static void UInt64ToNumber(ulong value, ref NumberBuffer number) { number.DigitsCount = 20; number.IsNegative = false; byte* digitsPointer = number.GetDigitsPointer(); byte* bufferEnd = digitsPointer + 20; while (High32(value) != 0) { bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9); } bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), 0); int num = (number.Scale = (number.DigitsCount = (int)(digitsPointer + 20 - bufferEnd))); byte* digitsPointer2 = number.GetDigitsPointer(); while (--num >= 0) { *(digitsPointer2++) = *(bufferEnd++); } *digitsPointer2 = 0; } internal unsafe static string UInt64ToDecStr(ulong value, int digits) { if (digits < 1) { digits = 1; } int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value)); if (num == 1) { return s_singleDigitStringCache[value]; } string text = FastAllocateString(num); fixed (char* ptr = text) { char* bufferEnd = ptr + num; while (High32(value) != 0) { bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9); digits -= 9; } bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits); } return text; } private unsafe static bool TryUInt64ToDecStr(ulong value, int digits, Span<char> destination, out int charsWritten) { if (digits < 1) { digits = 1; } int num = Math.Max(digits, System.Buffers.Text.FormattingHelpers.CountDigits(value)); if (num > destination.Length) { charsWritten = 0; return false; } charsWritten = num; fixed (char* ptr = &MemoryMarshal.GetReference(destination)) { char* bufferEnd = ptr + num; while (High32(value) != 0) { bufferEnd = UInt32ToDecChars(bufferEnd, Int64DivMod1E9(ref value), 9); digits -= 9; } bufferEnd = UInt32ToDecChars(bufferEnd, Low32(value), digits); } return true; } internal static char ParseFormatSpecifier(ReadOnlySpan<char> format, out int digits) { char c = '\0'; if (format.Length > 0) { c = format[0]; if ((uint)(c - 65) <= 25u || (uint)(c - 97) <= 25u) { if (format.Length == 1) { digits = -1; return c; } if (format.Length == 2) { int num = format[1] - 48; if ((uint)num < 10u) { digits = num; return c; } } else if (format.Length == 3) { int num2 = format[1] - 48; int num3 = format[2] - 48; if ((uint)num2 < 10u && (uint)num3 < 10u) { digits = num2 * 10 + num3; return c; } } int num4 = 0; int num5 = 1; while (num5 < format.Length && (uint)(format[num5] - 48) < 10u && num4 < 10) { num4 = num4 * 10 + format[num5++] - 48; } if (num5 == format.Length || format[num5] == '\0') { digits = num4; return c; } } } digits = -1; if (format.Length != 0 && c != 0) { return '\0'; } return 'G'; } internal static void NumberToString(ref System.Text.ValueStringBuilder sb, ref NumberBuffer number, char format, int nMaxDigits, NumberFormatInfo info) { bool isCorrectlyRounded = number.Kind == NumberBufferKind.FloatingPoint; bool bSuppressScientific; switch (format) { case 'C': case 'c': if (nMaxDigits < 0) { nMaxDigits = info.CurrencyDecimalDigits; } RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded); FormatCurrency(ref sb, ref number, nMaxDigits, info); return; case 'F': case 'f': if (nMaxDigits < 0) { nMaxDigits = info.NumberDecimalDigits; } RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded); if (number.IsNegative) { sb.Append(info.NegativeSign); } FormatFixed(ref sb, ref number, nMaxDigits, null, info.NumberDecimalSeparator, null); return; case 'N': case 'n': if (nMaxDigits < 0) { nMaxDigits = info.NumberDecimalDigits; } RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded); FormatNumber(ref sb, ref number, nMaxDigits, info); return; case 'E': case 'e': if (nMaxDigits < 0) { nMaxDigits = 6; } nMaxDigits++; RoundNumber(ref number, nMaxDigits, isCorrectlyRounded); if (number.IsNegative) { sb.Append(info.NegativeSign); } FormatScientific(ref sb, ref number, nMaxDigits, info, format); return; case 'G': case 'g': bSuppressScientific = false; if (nMaxDigits < 1) { if (number.Kind == NumberBufferKind.Decimal && nMaxDigits == -1) { bSuppressScientific = true; if (number.Digits[0] != 0) { goto IL_0189; } goto IL_019e; } nMaxDigits = number.DigitsCount; } RoundNumber(ref number, nMaxDigits, isCorrectlyRounded); goto IL_0189; case 'P': case 'p': if (nMaxDigits < 0) { nMaxDigits = info.PercentDecimalDigits; } number.Scale += 2; RoundNumber(ref number, number.Scale + nMaxDigits, isCorrectlyRounded); FormatPercent(ref sb, ref number, nMaxDigits, info); return; case 'R': case 'r': { if (number.Kind != NumberBufferKind.FloatingPoint) { break; } format = (char)(format - 11); goto case 'G'; } IL_0189: if (number.IsNegative) { sb.Append(info.NegativeSign); } goto IL_019e; IL_019e: FormatGeneral(ref sb, ref number, nMaxDigits, info, (char)(format - 2), bSuppressScientific); return; } throw new FormatException("SR.Argument_BadFormatSpecifier"); } internal unsafe static void NumberToStringFormat(ref System.Text.ValueStringBuilder sb, ref NumberBuffer number, ReadOnlySpan<char> format, NumberFormatInfo info) { int num = 0; byte* digitsPointer = number.GetDigitsPointer(); int num2 = FindSection(format, (*digitsPointer == 0) ? 2 : (number.IsNegative ? 1 : 0)); int num3; int num4; bool flag; bool flag2; int num5; int num6; int num9; while (true) { num3 = 0; num4 = -1; num5 = int.MaxValue; num6 = 0; flag = false; int num7 = -1; flag2 = false; int num8 = 0; num9 = num2; fixed (char* ptr = &MemoryMarshal.GetReference(format)) { char c; while (num9 < format.Length && (c = ptr[num9++]) != 0) { switch (c) { case ';': break; case '#': num3++; continue; case '0': if (num5 == int.MaxValue) { num5 = num3; } num3++; num6 = num3; continue; case '.': if (num4 < 0) { num4 = num3; } continue; case ',': if (num3 <= 0 || num4 >= 0) { continue; } if (num7 >= 0) { if (num7 == num3) { num++; continue; } flag2 = true; } num7 = num3; num = 1; continue; case '%': num8 += 2; continue; case '‰': num8 += 3; continue; case '"': case '\'': while (num9 < format.Length && ptr[num9] != 0 && ptr[num9++] != c) { } continue; case '\\': if (num9 < format.Length && ptr[num9] != 0) { num9++; } continue; case 'E': case 'e': if ((num9 < format.Length && ptr[num9] == '0') || (num9 + 1 < format.Length && (ptr[num9] == '+' || ptr[num9] == '-') && ptr[num9 + 1] == '0')) { while (++num9 < format.Length && ptr[num9] == '0') { } flag = true; } continue; default: continue; } break; } } if (num4 < 0) { num4 = num3; } if (num7 >= 0) { if (num7 == num4) { num8 -= num * 3; } else { flag2 = true; } } if (*digitsPointer != 0) { number.Scale += num8; int pos = (flag ? num3 : (number.Scale + num3 - num4)); RoundNumber(ref number, pos, isCorrectlyRounded: false); if (*digitsPointer != 0) { break; } num9 = FindSection(format, 2); if (num9 == num2) { break; } num2 = num9; continue; } if (number.Kind != NumberBufferKind.FloatingPoint) { number.IsNegative = false; } number.Scale = 0; break; } num5 = ((num5 < num4) ? (num4 - num5) : 0); num6 = ((num6 > num4) ? (num4 - num6) : 0); int num10; int num11; if (flag) { num10 = num4; num11 = 0; } else { num10 = ((number.Scale > num4) ? number.Scale : num4); num11 = number.Scale - num4; } num9 = num2; Span<int> span = stackalloc int[4]; int num12 = -1; if (flag2 && info.NumberGroupSeparator.Length > 0) { int[] numberGroupSizes = info.NumberGroupSizes; int num13 = 0; int i = 0; int num14 = numberGroupSizes.Length; if (num14 != 0) { i = numberGroupSizes[num13]; } int num15 = i; int num16 = num10 + ((num11 < 0) ? num11 : 0); for (int num17 = ((num5 > num16) ? num5 : num16); num17 > i; i += num15) { if (num15 == 0) { break; } num12++; if (num12 >= span.Length) { int[] array = new int[span.Length * 2]; span.CopyTo(array); span = array; } span[num12] = i; if (num13 < num14 - 1) { num13++; num15 = numberGroupSizes[num13]; } } } if (number.IsNegative && num2 == 0 && number.Scale != 0) { sb.Append(info.NegativeSign); } bool flag3 = false;

Lethal Company

ZString

Details

Categories

BepInEx/core/ZString/netstandard2.1/ZString.dll

Categories

BepInEx/core/ZString/netstandard2.1/ZString.dll

Categories