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.Reflection;
using System.Runtime.CompilerServices;
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(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[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 Cysharp.Text
{
	internal static class EnumUtil<T>
	{
		private const string InvalidName = "$";

		private static readonly Dictionary<T, string> names;

		private static readonly Dictionary<T, byte[]> utf8names;

		static EnumUtil()
		{
			string[] array = Enum.GetNames(typeof(T));
			Array values = Enum.GetValues(typeof(T));
			names = new Dictionary<T, string>(array.Length);
			utf8names = new Dictionary<T, byte[]>(array.Length);
			for (int i = 0; i < array.Length; i++)
			{
				T key = (T)values.GetValue(i);
				if (names.ContainsKey(key))
				{
					names[key] = "$";
					utf8names[key] = Array.Empty<byte>();
				}
				else
				{
					names.Add(key, array[i]);
					utf8names.Add(key, Encoding.UTF8.GetBytes(array[i]));
				}
			}
		}

		public static bool TryFormatUtf16(T value, Span<char> dest, out int written, ReadOnlySpan<char> _)
		{
			if (!names.TryGetValue(value, out string value2) || value2 == "$")
			{
				value2 = value.ToString();
			}
			written = value2.Length;
			return value2.AsSpan().TryCopyTo(dest);
		}

		public static bool TryFormatUtf8(T value, Span<byte> dest, out int written, StandardFormat _)
		{
			if (!utf8names.TryGetValue(value, out byte[] value2) || value2.Length == 0)
			{
				value2 = Encoding.UTF8.GetBytes(value.ToString());
			}
			written = value2.Length;
			return value2.AsSpan().TryCopyTo(dest);
		}
	}
	internal static class ExceptionUtil
	{
		internal static void ThrowArgumentException(string paramName)
		{
			throw new ArgumentException("Can't format argument.", paramName);
		}

		internal static void ThrowFormatException()
		{
			throw new FormatException("Index (zero based) must be greater than or equal to zero and less than the size of the argument list.");
		}

		internal static void ThrowFormatError()
		{
			throw new FormatException("Input string was not in a correct format.");
		}
	}
	internal static class FastNumberWriter
	{
		public static bool TryWriteInt64(Span<char> buffer, out int charsWritten, long value)
		{
			int num = 0;
			charsWritten = 0;
			long num2 = value;
			if (value < 0)
			{
				if (value == long.MinValue)
				{
					if (buffer.Length < 20)
					{
						return false;
					}
					buffer[num++] = '-';
					buffer[num++] = '9';
					buffer[num++] = '2';
					buffer[num++] = '2';
					buffer[num++] = '3';
					buffer[num++] = '3';
					buffer[num++] = '7';
					buffer[num++] = '2';
					buffer[num++] = '0';
					buffer[num++] = '3';
					buffer[num++] = '6';
					buffer[num++] = '8';
					buffer[num++] = '5';
					buffer[num++] = '4';
					buffer[num++] = '7';
					buffer[num++] = '7';
					buffer[num++] = '5';
					buffer[num++] = '8';
					buffer[num++] = '0';
					buffer[num++] = '8';
					charsWritten = num;
					return true;
				}
				if (buffer.Length < 1)
				{
					return false;
				}
				buffer[num++] = '-';
				num2 = -value;
			}
			if (num2 < 10000)
			{
				if (num2 < 10)
				{
					if (buffer.Length < 1)
					{
						return false;
					}
					goto IL_0677;
				}
				if (num2 < 100)
				{
					if (buffer.Length < 2)
					{
						return false;
					}
					goto IL_064e;
				}
				if (num2 < 1000)
				{
					if (buffer.Length < 3)
					{
						return false;
					}
					goto IL_0625;
				}
				if (buffer.Length < 4)
				{
					return false;
				}
				goto IL_05f9;
			}
			long num3 = num2 / 10000;
			num2 -= num3 * 10000;
			if (num3 < 10000)
			{
				if (num3 < 10)
				{
					if (buffer.Length < 5)
					{
						return false;
					}
					goto IL_05e6;
				}
				if (num3 < 100)
				{
					if (buffer.Length < 6)
					{
						return false;
					}
					goto IL_05bd;
				}
				if (num3 < 1000)
				{
					if (buffer.Length < 7)
					{
						return false;
					}
					goto IL_0594;
				}
				if (buffer.Length < 8)
				{
					return false;
				}
				goto IL_0568;
			}
			long num4 = num3 / 10000;
			num3 -= num4 * 10000;
			if (num4 < 10000)
			{
				if (num4 < 10)
				{
					if (buffer.Length < 9)
					{
						return false;
					}
					goto IL_0555;
				}
				if (num4 < 100)
				{
					if (buffer.Length < 10)
					{
						return false;
					}
					goto IL_052c;
				}
				if (num4 < 1000)
				{
					if (buffer.Length < 11)
					{
						return false;
					}
					goto IL_0503;
				}
				if (buffer.Length < 12)
				{
					return false;
				}
				goto IL_04d7;
			}
			long num5 = num4 / 10000;
			num4 -= num5 * 10000;
			if (num5 < 10000)
			{
				if (num5 < 10)
				{
					if (buffer.Length < 13)
					{
						return false;
					}
					goto IL_04c3;
				}
				if (num5 < 100)
				{
					if (buffer.Length < 14)
					{
						return false;
					}
					goto IL_0497;
				}
				if (num5 < 1000)
				{
					if (buffer.Length < 15)
					{
						return false;
					}
					goto IL_046b;
				}
				if (buffer.Length < 16)
				{
					return false;
				}
				goto IL_043c;
			}
			long num6 = num5 / 10000;
			num5 -= num6 * 10000;
			if (num6 < 10000)
			{
				if (num6 < 10)
				{
					if (buffer.Length < 17)
					{
						return false;
					}
					goto IL_0428;
				}
				if (num6 < 100)
				{
					if (buffer.Length < 18)
					{
						return false;
					}
					goto IL_03fc;
				}
				if (num6 < 1000)
				{
					if (buffer.Length < 19)
					{
						return false;
					}
					goto IL_03d0;
				}
				if (buffer.Length < 20)
				{
					return false;
				}
			}
			long num7;
			buffer[num++] = (char)(48 + (num7 = num6 * 8389 >> 23));
			num6 -= num7 * 1000;
			goto IL_03d0;
			IL_0555:
			buffer[num++] = (char)(48 + num4);
			goto IL_0568;
			IL_0594:
			buffer[num++] = (char)(48 + (num7 = num3 * 5243 >> 19));
			num3 -= num7 * 100;
			goto IL_05bd;
			IL_05bd:
			buffer[num++] = (char)(48 + (num7 = num3 * 6554 >> 16));
			num3 -= num7 * 10;
			goto IL_05e6;
			IL_05f9:
			buffer[num++] = (char)(48 + (num7 = num2 * 8389 >> 23));
			num2 -= num7 * 1000;
			goto IL_0625;
			IL_0497:
			buffer[num++] = (char)(48 + (num7 = num5 * 6554 >> 16));
			num5 -= num7 * 10;
			goto IL_04c3;
			IL_04d7:
			buffer[num++] = (char)(48 + (num7 = num4 * 8389 >> 23));
			num4 -= num7 * 1000;
			goto IL_0503;
			IL_0625:
			buffer[num++] = (char)(48 + (num7 = num2 * 5243 >> 19));
			num2 -= num7 * 100;
			goto IL_064e;
			IL_0428:
			buffer[num++] = (char)(48 + num6);
			goto IL_043c;
			IL_0677:
			buffer[num++] = (char)(48 + num2);
			charsWritten = num;
			return true;
			IL_03d0:
			buffer[num++] = (char)(48 + (num7 = num6 * 5243 >> 19));
			num6 -= num7 * 100;
			goto IL_03fc;
			IL_05e6:
			buffer[num++] = (char)(48 + num3);
			goto IL_05f9;
			IL_03fc:
			buffer[num++] = (char)(48 + (num7 = num6 * 6554 >> 16));
			num6 -= num7 * 10;
			goto IL_0428;
			IL_043c:
			buffer[num++] = (char)(48 + (num7 = num5 * 8389 >> 23));
			num5 -= num7 * 1000;
			goto IL_046b;
			IL_064e:
			buffer[num++] = (char)(48 + (num7 = num2 * 6554 >> 16));
			num2 -= num7 * 10;
			goto IL_0677;
			IL_046b:
			buffer[num++] = (char)(48 + (num7 = num5 * 5243 >> 19));
			num5 -= num7 * 100;
			goto IL_0497;
			IL_04c3:
			buffer[num++] = (char)(48 + num5);
			goto IL_04d7;
			IL_0568:
			buffer[num++] = (char)(48 + (num7 = num3 * 8389 >> 23));
			num3 -= num7 * 1000;
			goto IL_0594;
			IL_0503:
			buffer[num++] = (char)(48 + (num7 = num4 * 5243 >> 19));
			num4 -= num7 * 100;
			goto IL_052c;
			IL_052c:
			buffer[num++] = (char)(48 + (num7 = num4 * 6554 >> 16));
			num4 -= num7 * 10;
			goto IL_0555;
		}

		public static bool TryWriteUInt64(Span<char> buffer, out int charsWritten, ulong value)
		{
			ulong num = value;
			charsWritten = 0;
			int num2 = 0;
			if (num < 10000)
			{
				if (num < 10)
				{
					if (buffer.Length < 1)
					{
						return false;
					}
					goto IL_0518;
				}
				if (num < 100)
				{
					if (buffer.Length < 2)
					{
						return false;
					}
					goto IL_04ed;
				}
				if (num < 1000)
				{
					if (buffer.Length < 3)
					{
						return false;
					}
					goto IL_04c2;
				}
				if (buffer.Length < 4)
				{
					return false;
				}
				goto IL_0494;
			}
			ulong num3 = num / 10000;
			num -= num3 * 10000;
			if (num3 < 10000)
			{
				if (num3 < 10)
				{
					if (buffer.Length < 5)
					{
						return false;
					}
					goto IL_047f;
				}
				if (num3 < 100)
				{
					if (buffer.Length < 6)
					{
						return false;
					}
					goto IL_0454;
				}
				if (num3 < 1000)
				{
					if (buffer.Length < 7)
					{
						return false;
					}
					goto IL_0429;
				}
				if (buffer.Length < 8)
				{
					return false;
				}
				goto IL_03fb;
			}
			ulong num4 = num3 / 10000;
			num3 -= num4 * 10000;
			if (num4 < 10000)
			{
				if (num4 < 10)
				{
					if (buffer.Length < 9)
					{
						return false;
					}
					goto IL_03e6;
				}
				if (num4 < 100)
				{
					if (buffer.Length < 10)
					{
						return false;
					}
					goto IL_03bb;
				}
				if (num4 < 1000)
				{
					if (buffer.Length < 11)
					{
						return false;
					}
					goto IL_0390;
				}
				if (buffer.Length < 12)
				{
					return false;
				}
				goto IL_0362;
			}
			ulong num5 = num4 / 10000;
			num4 -= num5 * 10000;
			if (num5 < 10000)
			{
				if (num5 < 10)
				{
					if (buffer.Length < 13)
					{
						return false;
					}
					goto IL_034d;
				}
				if (num5 < 100)
				{
					if (buffer.Length < 14)
					{
						return false;
					}
					goto IL_0322;
				}
				if (num5 < 1000)
				{
					if (buffer.Length < 15)
					{
						return false;
					}
					goto IL_02f7;
				}
				if (buffer.Length < 16)
				{
					return false;
				}
				goto IL_02c9;
			}
			ulong num6 = num5 / 10000;
			num5 -= num6 * 10000;
			if (num6 < 10000)
			{
				if (num6 < 10)
				{
					if (buffer.Length < 17)
					{
						return false;
					}
					goto IL_02b3;
				}
				if (num6 < 100)
				{
					if (buffer.Length < 18)
					{
						return false;
					}
					goto IL_0285;
				}
				if (num6 < 1000)
				{
					if (buffer.Length < 19)
					{
						return false;
					}
					goto IL_0257;
				}
				if (buffer.Length < 20)
				{
					return false;
				}
			}
			ulong num7;
			buffer[num2++] = (char)(48 + (num7 = num6 * 8389 >> 23));
			num6 -= num7 * 1000;
			goto IL_0257;
			IL_0518:
			buffer[num2++] = (char)(48 + num);
			charsWritten = num2;
			return true;
			IL_0257:
			buffer[num2++] = (char)(48 + (num7 = num6 * 5243 >> 19));
			num6 -= num7 * 100;
			goto IL_0285;
			IL_047f:
			buffer[num2++] = (char)(48 + num3);
			goto IL_0494;
			IL_0285:
			buffer[num2++] = (char)(48 + (num7 = num6 * 6554 >> 16));
			num6 -= num7 * 10;
			goto IL_02b3;
			IL_02c9:
			buffer[num2++] = (char)(48 + (num7 = num5 * 8389 >> 23));
			num5 -= num7 * 1000;
			goto IL_02f7;
			IL_04ed:
			buffer[num2++] = (char)(48 + (num7 = num * 6554 >> 16));
			num -= num7 * 10;
			goto IL_0518;
			IL_02f7:
			buffer[num2++] = (char)(48 + (num7 = num5 * 5243 >> 19));
			num5 -= num7 * 100;
			goto IL_0322;
			IL_034d:
			buffer[num2++] = (char)(48 + num5);
			goto IL_0362;
			IL_03fb:
			buffer[num2++] = (char)(48 + (num7 = num3 * 8389 >> 23));
			num3 -= num7 * 1000;
			goto IL_0429;
			IL_0390:
			buffer[num2++] = (char)(48 + (num7 = num4 * 5243 >> 19));
			num4 -= num7 * 100;
			goto IL_03bb;
			IL_03bb:
			buffer[num2++] = (char)(48 + (num7 = num4 * 6554 >> 16));
			num4 -= num7 * 10;
			goto IL_03e6;
			IL_02b3:
			buffer[num2++] = (char)(48 + num6);
			goto IL_02c9;
			IL_03e6:
			buffer[num2++] = (char)(48 + num4);
			goto IL_03fb;
			IL_0429:
			buffer[num2++] = (char)(48 + (num7 = num3 * 5243 >> 19));
			num3 -= num7 * 100;
			goto IL_0454;
			IL_0322:
			buffer[num2++] = (char)(48 + (num7 = num5 * 6554 >> 16));
			num5 -= num7 * 10;
			goto IL_034d;
			IL_0454:
			buffer[num2++] = (char)(48 + (num7 = num3 * 6554 >> 16));
			num3 -= num7 * 10;
			goto IL_047f;
			IL_0494:
			buffer[num2++] = (char)(48 + (num7 = num * 8389 >> 23));
			num -= num7 * 1000;
			goto IL_04c2;
			IL_0362:
			buffer[num2++] = (char)(48 + (num7 = num4 * 8389 >> 23));
			num4 -= num7 * 1000;
			goto IL_0390;
			IL_04c2:
			buffer[num2++] = (char)(48 + (num7 = num * 5243 >> 19));
			num -= num7 * 100;
			goto IL_04ed;
		}
	}
	internal static class Utf16FormatHelper
	{
		private const char sp = ' ';

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void FormatTo<TBufferWriter, T>(ref TBufferWriter sb, T arg, int width, ReadOnlySpan<char> format, string argName) where TBufferWriter : IBufferWriter<char>
		{
			if (width <= 0)
			{
				Span<char> span = sb.GetSpan();
				if (!Utf16ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, span, out var charsWritten, format))
				{
					sb.Advance(0);
					ref TBufferWriter reference = ref sb;
					TBufferWriter val = default(TBufferWriter);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					span = reference.GetSpan(Math.Max(span.Length + 1, charsWritten));
					if (!Utf16ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, span, out charsWritten, format))
					{
						ExceptionUtil.ThrowArgumentException(argName);
					}
				}
				sb.Advance(charsWritten);
				width *= -1;
				int num = width - charsWritten;
				if (width > 0 && num > 0)
				{
					sb.GetSpan(num).Fill(' ');
					sb.Advance(num);
				}
			}
			else
			{
				FormatToRightJustify(ref sb, arg, width, format, argName);
			}
		}

		private static void FormatToRightJustify<TBufferWriter, T>(ref TBufferWriter sb, T arg, int width, ReadOnlySpan<char> format, string argName) where TBufferWriter : IBufferWriter<char>
		{
			if (typeof(T) == typeof(string))
			{
				string text = Unsafe.As<string>(arg);
				int num = width - text.Length;
				if (num > 0)
				{
					sb.GetSpan(num).Fill(' ');
					sb.Advance(num);
				}
				ref TBufferWriter reference = ref sb;
				TBufferWriter val = default(TBufferWriter);
				if (val == null)
				{
					val = reference;
					reference = ref val;
				}
				Span<char> span = reference.GetSpan(text.Length);
				text.AsSpan().CopyTo(span);
				ref TBufferWriter reference2 = ref sb;
				val = default(TBufferWriter);
				if (val == null)
				{
					val = reference2;
					reference2 = ref val;
				}
				reference2.Advance(text.Length);
				return;
			}
			Span<char> destination = stackalloc char[typeof(T).IsValueType ? (Unsafe.SizeOf<T>() * 8) : 1024];
			if (!Utf16ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, destination, out var charsWritten, format))
			{
				destination = stackalloc char[destination.Length * 2];
				if (!Utf16ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, destination, out charsWritten, format))
				{
					ExceptionUtil.ThrowArgumentException(argName);
				}
			}
			int num2 = width - charsWritten;
			if (num2 > 0)
			{
				sb.GetSpan(num2).Fill(' ');
				sb.Advance(num2);
			}
			Span<char> span2 = sb.GetSpan(charsWritten);
			destination.CopyTo(span2);
			sb.Advance(charsWritten);
		}
	}
	internal static class Utf8FormatHelper
	{
		private const byte sp = 32;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void FormatTo<TBufferWriter, T>(ref TBufferWriter sb, T arg, int width, StandardFormat format, string argName) where TBufferWriter : IBufferWriter<byte>
		{
			if (width <= 0)
			{
				Span<byte> span = sb.GetSpan();
				if (!Utf8ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, span, out var written, format))
				{
					sb.Advance(0);
					ref TBufferWriter reference = ref sb;
					TBufferWriter val = default(TBufferWriter);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					span = reference.GetSpan(Math.Max(span.Length + 1, written));
					if (!Utf8ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, span, out written, format))
					{
						ExceptionUtil.ThrowArgumentException(argName);
					}
				}
				sb.Advance(written);
				width *= -1;
				int num = width - written;
				if (width > 0 && num > 0)
				{
					sb.GetSpan(num).Fill(32);
					sb.Advance(num);
				}
			}
			else
			{
				FormatToRightJustify(ref sb, arg, width, format, argName);
			}
		}

		private static void FormatToRightJustify<TBufferWriter, T>(ref TBufferWriter sb, T arg, int width, StandardFormat format, string argName) where TBufferWriter : IBufferWriter<byte>
		{
			if (typeof(T) == typeof(string))
			{
				string text = Unsafe.As<string>(arg);
				int num = width - text.Length;
				if (num > 0)
				{
					sb.GetSpan(num).Fill(32);
					sb.Advance(num);
				}
				ZString.AppendChars(ref sb, text.AsSpan());
				return;
			}
			Span<byte> destination = stackalloc byte[typeof(T).IsValueType ? (Unsafe.SizeOf<T>() * 8) : 1024];
			if (!Utf8ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, destination, out var written, format))
			{
				destination = stackalloc byte[destination.Length * 2];
				if (!Utf8ValueStringBuilder.FormatterCache<T>.TryFormatDelegate(arg, destination, out written, format))
				{
					ExceptionUtil.ThrowArgumentException(argName);
				}
			}
			int num2 = width - written;
			if (num2 > 0)
			{
				sb.GetSpan(num2).Fill(32);
				sb.Advance(num2);
			}
			Span<byte> span = sb.GetSpan(written);
			destination.CopyTo(span);
			sb.Advance(written);
		}
	}
	internal static class FormatParser
	{
		public readonly ref struct ParseResult
		{
			public readonly int Index;

			public readonly ReadOnlySpan<char> FormatString;

			public readonly int LastIndex;

			public readonly int Alignment;

			public ParseResult(int index, ReadOnlySpan<char> formatString, int lastIndex, int alignment)
			{
				Index = index;
				FormatString = formatString;
				LastIndex = lastIndex;
				Alignment = alignment;
			}
		}

		internal const int ArgLengthLimit = 16;

		internal const int WidthLimit = 1000;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ParserScanResult ScanFormatString(string format, ref int i)
		{
			int length = format.Length;
			char c = format[i];
			i++;
			switch (c)
			{
			case '}':
				if (i < length && format[i] == '}')
				{
					i++;
					return ParserScanResult.EscapedChar;
				}
				ExceptionUtil.ThrowFormatError();
				return ParserScanResult.NormalChar;
			case '{':
				if (i < length && format[i] == '{')
				{
					i++;
					return ParserScanResult.EscapedChar;
				}
				i--;
				return ParserScanResult.BraceOpen;
			default:
				return ParserScanResult.NormalChar;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ParserScanResult ScanFormatString(ReadOnlySpan<char> format, ref int i)
		{
			int length = format.Length;
			char c = format[i];
			i++;
			switch (c)
			{
			case '}':
				if (i < length && format[i] == '}')
				{
					i++;
					return ParserScanResult.EscapedChar;
				}
				ExceptionUtil.ThrowFormatError();
				return ParserScanResult.NormalChar;
			case '{':
				if (i < length && format[i] == '{')
				{
					i++;
					return ParserScanResult.EscapedChar;
				}
				i--;
				return ParserScanResult.BraceOpen;
			default:
				return ParserScanResult.NormalChar;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsDigit(char c)
		{
			if ('0' <= c)
			{
				return c <= '9';
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ParseResult Parse(ReadOnlySpan<char> format, int i)
		{
			char c = '\0';
			int length = format.Length;
			i++;
			if (i == length || !IsDigit(c = format[i]))
			{
				ExceptionUtil.ThrowFormatError();
			}
			int num = 0;
			do
			{
				num = num * 10 + c - 48;
				if (++i == length)
				{
					ExceptionUtil.ThrowFormatError();
				}
				c = format[i];
			}
			while (IsDigit(c) && num < 16);
			if (num >= 16)
			{
				ExceptionUtil.ThrowFormatException();
			}
			while (i < length && (c = format[i]) == ' ')
			{
				i++;
			}
			int num2 = 0;
			if (c == ',')
			{
				i++;
				while (i < length && (c = format[i]) == ' ')
				{
					i++;
				}
				if (i == length)
				{
					ExceptionUtil.ThrowFormatError();
				}
				bool flag = false;
				if (c == '-')
				{
					flag = true;
					if (++i == length)
					{
						ExceptionUtil.ThrowFormatError();
					}
					c = format[i];
				}
				if (!IsDigit(c))
				{
					ExceptionUtil.ThrowFormatError();
				}
				do
				{
					num2 = num2 * 10 + c - 48;
					if (++i == length)
					{
						ExceptionUtil.ThrowFormatError();
					}
					c = format[i];
				}
				while (IsDigit(c) && num2 < 1000);
				if (flag)
				{
					num2 *= -1;
				}
			}
			while (i < length && (c = format[i]) == ' ')
			{
				i++;
			}
			ReadOnlySpan<char> formatString = default(ReadOnlySpan<char>);
			switch (c)
			{
			case ':':
			{
				i++;
				int num3 = i;
				while (true)
				{
					if (i == length)
					{
						ExceptionUtil.ThrowFormatError();
					}
					switch (format[i])
					{
					case '{':
						ExceptionUtil.ThrowFormatError();
						goto IL_016c;
					default:
						goto IL_016c;
					case '}':
						break;
					}
					break;
					IL_016c:
					i++;
				}
				if (i > num3)
				{
					formatString = format.Slice(num3, i - num3);
				}
				break;
			}
			default:
				ExceptionUtil.ThrowFormatError();
				break;
			case '}':
				break;
			}
			i++;
			return new ParseResult(num, formatString, i, num2);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ParseResult Parse(string format, int i)
		{
			char c = '\0';
			int length = format.Length;
			i++;
			if (i == length || !IsDigit(c = format[i]))
			{
				ExceptionUtil.ThrowFormatError();
			}
			int num = 0;
			do
			{
				num = num * 10 + c - 48;
				if (++i == length)
				{
					ExceptionUtil.ThrowFormatError();
				}
				c = format[i];
			}
			while (IsDigit(c) && num < 16);
			if (num >= 16)
			{
				ExceptionUtil.ThrowFormatException();
			}
			while (i < length && (c = format[i]) == ' ')
			{
				i++;
			}
			int num2 = 0;
			if (c == ',')
			{
				i++;
				while (i < length && (c = format[i]) == ' ')
				{
					i++;
				}
				if (i == length)
				{
					ExceptionUtil.ThrowFormatError();
				}
				bool flag = false;
				if (c == '-')
				{
					flag = true;
					if (++i == length)
					{
						ExceptionUtil.ThrowFormatError();
					}
					c = format[i];
				}
				if (!IsDigit(c))
				{
					ExceptionUtil.ThrowFormatError();
				}
				do
				{
					num2 = num2 * 10 + c - 48;
					if (++i == length)
					{
						ExceptionUtil.ThrowFormatError();
					}
					c = format[i];
				}
				while (IsDigit(c) && num2 < 1000);
				if (flag)
				{
					num2 *= -1;
				}
			}
			while (i < length && (c = format[i]) == ' ')
			{
				i++;
			}
			ReadOnlySpan<char> formatString = default(ReadOnlySpan<char>);
			switch (c)
			{
			case ':':
			{
				i++;
				int num3 = i;
				while (true)
				{
					if (i == length)
					{
						ExceptionUtil.ThrowFormatError();
					}
					switch (format[i])
					{
					case '{':
						ExceptionUtil.ThrowFormatError();
						goto IL_015b;
					default:
						goto IL_015b;
					case '}':
						break;
					}
					break;
					IL_015b:
					i++;
				}
				if (i > num3)
				{
					formatString = format.AsSpan(num3, i - num3);
				}
				break;
			}
			default:
				ExceptionUtil.ThrowFormatError();
				break;
			case '}':
				break;
			}
			i++;
			return new ParseResult(num, formatString, i, num2);
		}
	}
	internal enum ParserScanResult
	{
		BraceOpen,
		EscapedChar,
		NormalChar
	}
	public interface IResettableBufferWriter<T> : IBufferWriter<T>
	{
		void Reset();
	}
	internal class NestedStringBuilderCreationException : InvalidOperationException
	{
		protected internal NestedStringBuilderCreationException(string typeName, string extraMessage = "")
			: base("A nested call with `notNested: true`, or Either You forgot to call " + typeName + ".Dispose() of  in the past." + extraMessage)
		{
		}

		protected internal NestedStringBuilderCreationException(string message, Exception innerException)
			: base(message, innerException)
		{
		}
	}
	public sealed class Utf16PreparedFormat<T1>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				case 9:
					Utf16FormatHelper.FormatTo(ref sb, arg10, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg10");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				case 9:
					Utf16FormatHelper.FormatTo(ref sb, arg10, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg10");
					break;
				case 10:
					Utf16FormatHelper.FormatTo(ref sb, arg11, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg11");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				case 9:
					Utf16FormatHelper.FormatTo(ref sb, arg10, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg10");
					break;
				case 10:
					Utf16FormatHelper.FormatTo(ref sb, arg11, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg11");
					break;
				case 11:
					Utf16FormatHelper.FormatTo(ref sb, arg12, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg12");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				case 9:
					Utf16FormatHelper.FormatTo(ref sb, arg10, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg10");
					break;
				case 10:
					Utf16FormatHelper.FormatTo(ref sb, arg11, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg11");
					break;
				case 11:
					Utf16FormatHelper.FormatTo(ref sb, arg12, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg12");
					break;
				case 12:
					Utf16FormatHelper.FormatTo(ref sb, arg13, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg13");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				case 9:
					Utf16FormatHelper.FormatTo(ref sb, arg10, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg10");
					break;
				case 10:
					Utf16FormatHelper.FormatTo(ref sb, arg11, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg11");
					break;
				case 11:
					Utf16FormatHelper.FormatTo(ref sb, arg12, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg12");
					break;
				case 12:
					Utf16FormatHelper.FormatTo(ref sb, arg13, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg13");
					break;
				case 13:
					Utf16FormatHelper.FormatTo(ref sb, arg14, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg14");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				case 9:
					Utf16FormatHelper.FormatTo(ref sb, arg10, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg10");
					break;
				case 10:
					Utf16FormatHelper.FormatTo(ref sb, arg11, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg11");
					break;
				case 11:
					Utf16FormatHelper.FormatTo(ref sb, arg12, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg12");
					break;
				case 12:
					Utf16FormatHelper.FormatTo(ref sb, arg13, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg13");
					break;
				case 13:
					Utf16FormatHelper.FormatTo(ref sb, arg14, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg14");
					break;
				case 14:
					Utf16FormatHelper.FormatTo(ref sb, arg15, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg15");
					break;
				}
			}
		}
	}
	public sealed class Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
	{
		private readonly Utf16FormatSegment[] segments;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf16PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf16Parse(format);
			int num = 0;
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				if (!utf16FormatSegment.IsFormatArgument)
				{
					num += utf16FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			Utf16ValueStringBuilder sb = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16) where TBufferWriter : IBufferWriter<char>
		{
			ReadOnlySpan<char> readOnlySpan = FormatString.AsSpan();
			Utf16FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf16FormatSegment utf16FormatSegment = array[i];
				switch (utf16FormatSegment.FormatIndex)
				{
				case -1:
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count);
					Span<char> span = sb.GetSpan(utf16FormatSegment.Count);
					readOnlySpan2.TryCopyTo(span);
					sb.Advance(utf16FormatSegment.Count);
					break;
				}
				case 0:
					Utf16FormatHelper.FormatTo(ref sb, arg1, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg1");
					break;
				case 1:
					Utf16FormatHelper.FormatTo(ref sb, arg2, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg2");
					break;
				case 2:
					Utf16FormatHelper.FormatTo(ref sb, arg3, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg3");
					break;
				case 3:
					Utf16FormatHelper.FormatTo(ref sb, arg4, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg4");
					break;
				case 4:
					Utf16FormatHelper.FormatTo(ref sb, arg5, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg5");
					break;
				case 5:
					Utf16FormatHelper.FormatTo(ref sb, arg6, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg6");
					break;
				case 6:
					Utf16FormatHelper.FormatTo(ref sb, arg7, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg7");
					break;
				case 7:
					Utf16FormatHelper.FormatTo(ref sb, arg8, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg8");
					break;
				case 8:
					Utf16FormatHelper.FormatTo(ref sb, arg9, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg9");
					break;
				case 9:
					Utf16FormatHelper.FormatTo(ref sb, arg10, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg10");
					break;
				case 10:
					Utf16FormatHelper.FormatTo(ref sb, arg11, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg11");
					break;
				case 11:
					Utf16FormatHelper.FormatTo(ref sb, arg12, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg12");
					break;
				case 12:
					Utf16FormatHelper.FormatTo(ref sb, arg13, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg13");
					break;
				case 13:
					Utf16FormatHelper.FormatTo(ref sb, arg14, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg14");
					break;
				case 14:
					Utf16FormatHelper.FormatTo(ref sb, arg15, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg15");
					break;
				case 15:
					Utf16FormatHelper.FormatTo(ref sb, arg16, utf16FormatSegment.Alignment, readOnlySpan.Slice(utf16FormatSegment.Offset, utf16FormatSegment.Count), "arg16");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				case 9:
					Utf8FormatHelper.FormatTo(ref sb, arg10, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg10");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				case 9:
					Utf8FormatHelper.FormatTo(ref sb, arg10, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg10");
					break;
				case 10:
					Utf8FormatHelper.FormatTo(ref sb, arg11, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg11");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				case 9:
					Utf8FormatHelper.FormatTo(ref sb, arg10, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg10");
					break;
				case 10:
					Utf8FormatHelper.FormatTo(ref sb, arg11, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg11");
					break;
				case 11:
					Utf8FormatHelper.FormatTo(ref sb, arg12, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg12");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				case 9:
					Utf8FormatHelper.FormatTo(ref sb, arg10, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg10");
					break;
				case 10:
					Utf8FormatHelper.FormatTo(ref sb, arg11, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg11");
					break;
				case 11:
					Utf8FormatHelper.FormatTo(ref sb, arg12, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg12");
					break;
				case 12:
					Utf8FormatHelper.FormatTo(ref sb, arg13, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg13");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				case 9:
					Utf8FormatHelper.FormatTo(ref sb, arg10, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg10");
					break;
				case 10:
					Utf8FormatHelper.FormatTo(ref sb, arg11, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg11");
					break;
				case 11:
					Utf8FormatHelper.FormatTo(ref sb, arg12, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg12");
					break;
				case 12:
					Utf8FormatHelper.FormatTo(ref sb, arg13, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg13");
					break;
				case 13:
					Utf8FormatHelper.FormatTo(ref sb, arg14, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg14");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				case 9:
					Utf8FormatHelper.FormatTo(ref sb, arg10, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg10");
					break;
				case 10:
					Utf8FormatHelper.FormatTo(ref sb, arg11, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg11");
					break;
				case 11:
					Utf8FormatHelper.FormatTo(ref sb, arg12, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg12");
					break;
				case 12:
					Utf8FormatHelper.FormatTo(ref sb, arg13, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg13");
					break;
				case 13:
					Utf8FormatHelper.FormatTo(ref sb, arg14, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg14");
					break;
				case 14:
					Utf8FormatHelper.FormatTo(ref sb, arg15, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg15");
					break;
				}
			}
		}
	}
	public sealed class Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>
	{
		private readonly Utf8FormatSegment[] segments;

		private readonly byte[] utf8PreEncodedbuffer;

		public string FormatString { get; }

		public int MinSize { get; }

		public Utf8PreparedFormat(string format)
		{
			FormatString = format;
			segments = PreparedFormatHelper.Utf8Parse(format, out utf8PreEncodedbuffer);
			int num = 0;
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				if (!utf8FormatSegment.IsFormatArgument)
				{
					num += utf8FormatSegment.Count;
				}
			}
			MinSize = num;
		}

		public string Format(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			Utf8ValueStringBuilder sb = new Utf8ValueStringBuilder(disposeImmediately: true);
			try
			{
				FormatTo(ref sb, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
				return sb.ToString();
			}
			finally
			{
				sb.Dispose();
			}
		}

		public void FormatTo<TBufferWriter>(ref TBufferWriter sb, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16) where TBufferWriter : IBufferWriter<byte>
		{
			Span<byte> span = utf8PreEncodedbuffer.AsSpan();
			Utf8FormatSegment[] array = segments;
			for (int i = 0; i < array.Length; i++)
			{
				Utf8FormatSegment utf8FormatSegment = array[i];
				switch (utf8FormatSegment.FormatIndex)
				{
				case -1:
				{
					Span<byte> span2 = span.Slice(utf8FormatSegment.Offset, utf8FormatSegment.Count);
					Span<byte> span3 = sb.GetSpan(utf8FormatSegment.Count);
					span2.TryCopyTo(span3);
					sb.Advance(utf8FormatSegment.Count);
					break;
				}
				case 0:
					Utf8FormatHelper.FormatTo(ref sb, arg1, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg1");
					break;
				case 1:
					Utf8FormatHelper.FormatTo(ref sb, arg2, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg2");
					break;
				case 2:
					Utf8FormatHelper.FormatTo(ref sb, arg3, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg3");
					break;
				case 3:
					Utf8FormatHelper.FormatTo(ref sb, arg4, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg4");
					break;
				case 4:
					Utf8FormatHelper.FormatTo(ref sb, arg5, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg5");
					break;
				case 5:
					Utf8FormatHelper.FormatTo(ref sb, arg6, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg6");
					break;
				case 6:
					Utf8FormatHelper.FormatTo(ref sb, arg7, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg7");
					break;
				case 7:
					Utf8FormatHelper.FormatTo(ref sb, arg8, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg8");
					break;
				case 8:
					Utf8FormatHelper.FormatTo(ref sb, arg9, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg9");
					break;
				case 9:
					Utf8FormatHelper.FormatTo(ref sb, arg10, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg10");
					break;
				case 10:
					Utf8FormatHelper.FormatTo(ref sb, arg11, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg11");
					break;
				case 11:
					Utf8FormatHelper.FormatTo(ref sb, arg12, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg12");
					break;
				case 12:
					Utf8FormatHelper.FormatTo(ref sb, arg13, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg13");
					break;
				case 13:
					Utf8FormatHelper.FormatTo(ref sb, arg14, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg14");
					break;
				case 14:
					Utf8FormatHelper.FormatTo(ref sb, arg15, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg15");
					break;
				case 15:
					Utf8FormatHelper.FormatTo(ref sb, arg16, utf8FormatSegment.Alignment, utf8FormatSegment.StandardFormat, "arg16");
					break;
				}
			}
		}
	}
	internal static class PreparedFormatHelper
	{
		internal static Utf16FormatSegment[] Utf16Parse(string format)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			List<Utf16FormatSegment> list = new List<Utf16FormatSegment>();
			int i = 0;
			int length = format.Length;
			int num = 0;
			while (true)
			{
				if (i < length)
				{
					ParserScanResult parserScanResult = FormatParser.ScanFormatString(format, ref i);
					if (ParserScanResult.NormalChar == parserScanResult && i < length)
					{
						continue;
					}
					int num2 = i - num;
					if (ParserScanResult.EscapedChar == parserScanResult)
					{
						num2--;
					}
					if (num2 != 0)
					{
						list.Add(new Utf16FormatSegment(num, num2, -1, 0));
					}
					num = i;
					if (parserScanResult != 0)
					{
						continue;
					}
				}
				if (i >= length)
				{
					break;
				}
				FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
				num = parseResult.LastIndex;
				i = parseResult.LastIndex;
				list.Add(new Utf16FormatSegment(parseResult.LastIndex - parseResult.FormatString.Length - 1, parseResult.FormatString.Length, parseResult.Index, parseResult.Alignment));
			}
			return list.ToArray();
		}

		internal static Utf8FormatSegment[] Utf8Parse(string format, out byte[] utf8buffer)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			List<Utf8FormatSegment> list = new List<Utf8FormatSegment>();
			utf8buffer = new byte[Encoding.UTF8.GetMaxByteCount(format.Length)];
			int num = 0;
			int i = 0;
			int length = format.Length;
			int num2 = 0;
			while (true)
			{
				if (i < length)
				{
					ParserScanResult parserScanResult = FormatParser.ScanFormatString(format, ref i);
					if (ParserScanResult.NormalChar == parserScanResult && i < length)
					{
						continue;
					}
					int num3 = i - num2;
					if (ParserScanResult.EscapedChar == parserScanResult)
					{
						num3--;
					}
					if (num3 != 0)
					{
						int bytes = Encoding.UTF8.GetBytes(format, num2, num3, utf8buffer, num);
						list.Add(new Utf8FormatSegment(num, bytes, -1, default(StandardFormat), 0));
						num += bytes;
					}
					num2 = i;
					if (parserScanResult != 0)
					{
						continue;
					}
				}
				if (i >= length)
				{
					break;
				}
				FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
				num2 = parseResult.LastIndex;
				i = parseResult.LastIndex;
				list.Add(new Utf8FormatSegment(0, 0, parseResult.Index, StandardFormat.Parse(parseResult.FormatString), parseResult.Alignment));
			}
			return list.ToArray();
		}
	}
	internal readonly struct Utf8FormatSegment
	{
		public const int NotFormatIndex = -1;

		public readonly int Offset;

		public readonly int Count;

		public readonly int FormatIndex;

		public readonly StandardFormat StandardFormat;

		public readonly int Alignment;

		public bool IsFormatArgument => FormatIndex != -1;

		public Utf8FormatSegment(int offset, int count, int formatIndex, StandardFormat format, int alignment)
		{
			Offset = offset;
			Count = count;
			FormatIndex = formatIndex;
			StandardFormat = format;
			Alignment = alignment;
		}
	}
	internal readonly struct Utf16FormatSegment
	{
		public const int NotFormatIndex = -1;

		public readonly int Offset;

		public readonly int Count;

		public readonly int FormatIndex;

		public readonly int Alignment;

		public bool IsFormatArgument => FormatIndex != -1;

		public Utf16FormatSegment(int offset, int count, int formatIndex, int alignment)
		{
			Offset = offset;
			Count = count;
			FormatIndex = formatIndex;
			Alignment = alignment;
		}
	}
	internal readonly struct ReadOnlyListAdaptor<T> : IReadOnlyList<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>
	{
		private readonly IList<T> _list;

		public T this[int index] => _list[index];

		public int Count => _list.Count;

		public ReadOnlyListAdaptor(IList<T> list)
		{
			_list = list;
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _list.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	public struct Utf16ValueStringBuilder : IDisposable, IBufferWriter<char>, IResettableBufferWriter<char>
	{
		public delegate bool TryFormat<T>(T value, Span<char> destination, out int charsWritten, ReadOnlySpan<char> format);

		private static class ExceptionUtil
		{
			public static void ThrowArgumentOutOfRangeException(string paramName)
			{
				throw new ArgumentOutOfRangeException(paramName);
			}
		}

		public static class FormatterCache<T>
		{
			public static TryFormat<T> TryFormatDelegate;

			static FormatterCache()
			{
				TryFormat<T> tryFormat = (TryFormat<T>)CreateFormatter(typeof(T));
				if (tryFormat == null)
				{
					tryFormat = (typeof(T).IsEnum ? new TryFormat<T>(EnumUtil<T>.TryFormatUtf16) : ((!(typeof(T) == typeof(string))) ? new TryFormat<T>(TryFormatDefault) : new TryFormat<T>(TryFormatString)));
				}
				TryFormatDelegate = tryFormat;
			}

			private static bool TryFormatString(T value, Span<char> dest, out int written, ReadOnlySpan<char> format)
			{
				if (!((object)value is string text))
				{
					written = 0;
					return true;
				}
				written = text.Length;
				return text.AsSpan().TryCopyTo(dest);
			}

			private static bool TryFormatDefault(T value, Span<char> dest, out int written, ReadOnlySpan<char> format)
			{
				if (value == null)
				{
					written = 0;
					return true;
				}
				string text = (((object)value is IFormattable formattable && format.Length != 0) ? formattable.ToString(format.ToString(), null) : value.ToString());
				written = text.Length;
				return text.AsSpan().TryCopyTo(dest);
			}
		}

		private const int ThreadStaticBufferSize = 31111;

		private const int DefaultBufferSize = 32768;

		private static char newLine1;

		private static char newLine2;

		private static bool crlf;

		[ThreadStatic]
		private static char[]? scratchBuffer;

		[ThreadStatic]
		internal static bool scratchBufferUsed;

		private char[]? buffer;

		private int index;

		private bool disposeImmediately;

		public int Length => index;

		public void AppendJoin<T>(char separator, params T[] values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal<T>(separator2, values.AsSpan());
		}

		public void AppendJoin<T>(char separator, List<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, (IReadOnlyList<T>)values);
		}

		public void AppendJoin<T>(char separator, ReadOnlySpan<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, IEnumerable<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, ICollection<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values.AsEnumerable());
		}

		public void AppendJoin<T>(char separator, IList<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, IReadOnlyList<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, IReadOnlyCollection<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values.AsEnumerable());
		}

		public void AppendJoin<T>(string separator, params T[] values)
		{
			AppendJoinInternal<T>(separator.AsSpan(), values.AsSpan());
		}

		public void AppendJoin<T>(string separator, List<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), (IReadOnlyList<T>)values);
		}

		public void AppendJoin<T>(string separator, ReadOnlySpan<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, IEnumerable<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, ICollection<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values.AsEnumerable());
		}

		public void AppendJoin<T>(string separator, IList<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, IReadOnlyList<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, IReadOnlyCollection<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values.AsEnumerable());
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, IList<T> values)
		{
			IReadOnlyList<T> readOnlyList = values as IReadOnlyList<T>;
			readOnlyList = (IReadOnlyList<T>)(readOnlyList ?? ((object)new ReadOnlyListAdaptor<T>(values)));
			AppendJoinInternal(separator, readOnlyList);
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, IReadOnlyList<T> values)
		{
			int count = values.Count;
			for (int i = 0; i < count; i++)
			{
				if (i != 0)
				{
					Append(separator);
				}
				T val = values[i];
				if (typeof(T) == typeof(string))
				{
					string value = Unsafe.As<string>(val);
					if (!string.IsNullOrEmpty(value))
					{
						Append(value);
					}
				}
				else
				{
					Append(val);
				}
			}
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, ReadOnlySpan<T> values)
		{
			for (int i = 0; i < values.Length; i++)
			{
				if (i != 0)
				{
					Append(separator);
				}
				T val = values[i];
				if (typeof(T) == typeof(string))
				{
					string value = Unsafe.As<string>(val);
					if (!string.IsNullOrEmpty(value))
					{
						Append(value);
					}
				}
				else
				{
					Append(val);
				}
			}
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, IEnumerable<T> values)
		{
			bool flag = true;
			foreach (T value2 in values)
			{
				if (!flag)
				{
					Append(separator);
				}
				else
				{
					flag = false;
				}
				if (typeof(T) == typeof(string))
				{
					string value = Unsafe.As<string>(value2);
					if (!string.IsNullOrEmpty(value))
					{
						Append(value);
					}
				}
				else
				{
					Append(value2);
				}
			}
		}

		public void AppendFormat<T1>(string format, T1 arg1)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					if (parseResult.Index == 0)
					{
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1>(ReadOnlySpan<char> format, T1 arg1)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					if (parseResult.Index == 0)
					{
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2>(string format, T1 arg1, T2 arg2)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2>(ReadOnlySpan<char> format, T1 arg1, T2 arg2)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3>(string format, T1 arg1, T2 arg2, T3 arg3)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, parseResult.FormatString, "arg14");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, parseResult.FormatString, "arg14");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, parseResult.FormatString, "arg14");
						break;
					case 14:
						AppendFormatInternal(arg15, parseResult.Alignment, parseResult.FormatString, "arg15");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, parseResult.FormatString, "arg14");
						break;
					case 14:
						AppendFormatInternal(arg15, parseResult.Alignment, parseResult.FormatString, "arg15");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int count3 = i - num;
					Append(format, num, count3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, parseResult.FormatString, "arg14");
						break;
					case 14:
						AppendFormatInternal(arg15, parseResult.Alignment, parseResult.FormatString, "arg15");
						break;
					case 15:
						AppendFormatInternal(arg16, parseResult.Alignment, parseResult.FormatString, "arg16");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int length2 = i - num;
						Append(format.Slice(num, length2));
						i++;
						num = i;
						break;
					}
					int length3 = i - num;
					Append(format.Slice(num, length3));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, parseResult.FormatString, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, parseResult.FormatString, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, parseResult.FormatString, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, parseResult.FormatString, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, parseResult.FormatString, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, parseResult.FormatString, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, parseResult.FormatString, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, parseResult.FormatString, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, parseResult.FormatString, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, parseResult.FormatString, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, parseResult.FormatString, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, parseResult.FormatString, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, parseResult.FormatString, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, parseResult.FormatString, "arg14");
						break;
					case 14:
						AppendFormatInternal(arg15, parseResult.Alignment, parseResult.FormatString, "arg15");
						break;
					case 15:
						AppendFormatInternal(arg16, parseResult.Alignment, parseResult.FormatString, "arg16");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int length = i - num;
						Append(format.Slice(num, length));
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format.Slice(num, num2));
			}
		}

		private static object? CreateFormatter(Type type)
		{
			if (type == typeof(sbyte))
			{
				return (TryFormat<sbyte>)delegate(sbyte x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteInt64(dest, out written, x);
				};
			}
			if (type == typeof(short))
			{
				return (TryFormat<short>)delegate(short x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteInt64(dest, out written, x);
				};
			}
			if (type == typeof(int))
			{
				return (TryFormat<int>)delegate(int x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteInt64(dest, out written, x);
				};
			}
			if (type == typeof(long))
			{
				return (TryFormat<long>)delegate(long x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteInt64(dest, out written, x);
				};
			}
			if (type == typeof(byte))
			{
				return (TryFormat<byte>)delegate(byte x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteUInt64(dest, out written, x);
				};
			}
			if (type == typeof(ushort))
			{
				return (TryFormat<ushort>)delegate(ushort x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteUInt64(dest, out written, x);
				};
			}
			if (type == typeof(uint))
			{
				return (TryFormat<uint>)delegate(uint x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteUInt64(dest, out written, x);
				};
			}
			if (type == typeof(ulong))
			{
				return (TryFormat<ulong>)delegate(ulong x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (format.Length != 0) ? x.TryFormat(dest, out written, format) : FastNumberWriter.TryWriteUInt64(dest, out written, x);
				};
			}
			if (type == typeof(float))
			{
				return (TryFormat<float>)delegate(float x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return x.TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(double))
			{
				return (TryFormat<double>)delegate(double x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return x.TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(TimeSpan))
			{
				return (TryFormat<TimeSpan>)delegate(TimeSpan x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return x.TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(DateTime))
			{
				return (TryFormat<DateTime>)delegate(DateTime x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return x.TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(DateTimeOffset))
			{
				return (TryFormat<DateTimeOffset>)delegate(DateTimeOffset x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return x.TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(decimal))
			{
				return (TryFormat<decimal>)delegate(decimal x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return x.TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(Guid))
			{
				return (TryFormat<Guid>)delegate(Guid x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return x.TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(byte?))
			{
				return CreateNullableFormatter<byte>();
			}
			if (type == typeof(DateTime?))
			{
				return CreateNullableFormatter<DateTime>();
			}
			if (type == typeof(DateTimeOffset?))
			{
				return CreateNullableFormatter<DateTimeOffset>();
			}
			if (type == typeof(decimal?))
			{
				return CreateNullableFormatter<decimal>();
			}
			if (type == typeof(double?))
			{
				return CreateNullableFormatter<double>();
			}
			if (type == typeof(short?))
			{
				return CreateNullableFormatter<short>();
			}
			if (type == typeof(int?))
			{
				return CreateNullableFormatter<int>();
			}
			if (type == typeof(long?))
			{
				return CreateNullableFormatter<long>();
			}
			if (type == typeof(sbyte?))
			{
				return CreateNullableFormatter<sbyte>();
			}
			if (type == typeof(float?))
			{
				return CreateNullableFormatter<float>();
			}
			if (type == typeof(TimeSpan?))
			{
				return CreateNullableFormatter<TimeSpan>();
			}
			if (type == typeof(ushort?))
			{
				return CreateNullableFormatter<ushort>();
			}
			if (type == typeof(uint?))
			{
				return CreateNullableFormatter<uint>();
			}
			if (type == typeof(ulong?))
			{
				return CreateNullableFormatter<ulong>();
			}
			if (type == typeof(Guid?))
			{
				return CreateNullableFormatter<Guid>();
			}
			if (type == typeof(bool?))
			{
				return CreateNullableFormatter<bool>();
			}
			if (type == typeof(IntPtr))
			{
				return (TryFormat<IntPtr>)delegate(IntPtr x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (IntPtr.Size != 4) ? x.ToInt64().TryFormat(dest, out written, format) : x.ToInt32().TryFormat(dest, out written, format);
				};
			}
			if (type == typeof(UIntPtr))
			{
				return (TryFormat<UIntPtr>)delegate(UIntPtr x, Span<char> dest, out int written, ReadOnlySpan<char> format)
				{
					return (UIntPtr.Size != 4) ? x.ToUInt64().TryFormat(dest, out written, format) : x.ToUInt32().TryFormat(dest, out written, format);
				};
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(byte value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(byte value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(byte value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(byte value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTime value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTime value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTime value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTime value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTimeOffset value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTimeOffset value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTimeOffset value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTimeOffset value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(decimal value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(decimal value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(decimal value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(decimal value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(double value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(double value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(double value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(double value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(short value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(short value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(short value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(short value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(int value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(int value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(int value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(int value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(long value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(long value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(long value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(long value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(sbyte value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(sbyte value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(sbyte value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(sbyte value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(float value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(float value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(float value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(float value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(TimeSpan value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(TimeSpan value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(TimeSpan value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(TimeSpan value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ushort value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ushort value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ushort value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ushort value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(uint value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(uint value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(uint value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(uint value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ulong value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ulong value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ulong value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ulong value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(Guid value)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(Guid value, string format)
		{
			if (!value.TryFormat(buffer.AsSpan(index), out var charsWritten, format.AsSpan()))
			{
				Grow(charsWritten);
				if (!value.TryFormat(buffer.AsSpan(index), out charsWritten, format.AsSpan()))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(Guid value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(Guid value, string format)
		{
			Append(value, format);
			AppendLine();
		}

		static Utf16ValueStringBuilder()
		{
			char[] array = Environment.NewLine.ToCharArray();
			if (array.Length == 1)
			{
				newLine1 = array[0];
				crlf = false;
			}
			else
			{
				newLine1 = array[0];
				newLine2 = array[1];
				crlf = true;
			}
		}

		public ReadOnlySpan<char> AsSpan()
		{
			return buffer.AsSpan(0, index);
		}

		public ReadOnlyMemory<char> AsMemory()
		{
			return buffer.AsMemory(0, index);
		}

		public ArraySegment<char> AsArraySegment()
		{
			return new ArraySegment<char>(buffer, 0, index);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Utf16ValueStringBuilder(bool disposeImmediately)
		{
			if (disposeImmediately && scratchBufferUsed)
			{
				ThrowNestedException();
			}
			char[] array;
			if (disposeImmediately)
			{
				array = scratchBuffer;
				if (array == null)
				{
					array = (scratchBuffer = new char[31111]);
				}
				scratchBufferUsed = true;
			}
			else
			{
				array = ArrayPool<char>.Shared.Rent(32768);
			}
			buffer = array;
			index = 0;
			this.disposeImmediately = disposeImmediately;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Dispose()
		{
			if (buffer != null)
			{
				if (buffer.Length != 31111)
				{
					ArrayPool<char>.Shared.Return(buffer);
				}
				buffer = null;
				index = 0;
				if (disposeImmediately)
				{
					scratchBufferUsed = false;
				}
			}
		}

		public void Clear()
		{
			index = 0;
		}

		public void TryGrow(int sizeHint)
		{
			if (buffer.Length < index + sizeHint)
			{
				Grow(sizeHint);
			}
		}

		public void Grow(int sizeHint)
		{
			int num = buffer.Length * 2;
			if (sizeHint != 0)
			{
				num = Math.Max(num, index + sizeHint);
			}
			char[] array = ArrayPool<char>.Shared.Rent(num);
			buffer.CopyTo(array, 0);
			if (buffer.Length != 31111)
			{
				ArrayPool<char>.Shared.Return(buffer);
			}
			buffer = array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine()
		{
			if (crlf)
			{
				if (buffer.Length - index < 2)
				{
					Grow(2);
				}
				buffer[index] = newLine1;
				buffer[index + 1] = newLine2;
				index += 2;
			}
			else
			{
				if (buffer.Length - index < 1)
				{
					Grow(1);
				}
				buffer[index] = newLine1;
				index++;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(char value)
		{
			if (buffer.Length - index < 1)
			{
				Grow(1);
			}
			buffer[index++] = value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(char value, int repeatCount)
		{
			if (repeatCount < 0)
			{
				throw new ArgumentOutOfRangeException("repeatCount");
			}
			GetSpan(repeatCount).Fill(value);
			Advance(repeatCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(char value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(string value)
		{
			Append(value.AsSpan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(string value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(string value, int startIndex, int count)
		{
			if (value == null)
			{
				if (startIndex != 0 || count != 0)
				{
					throw new ArgumentNullException("value");
				}
			}
			else
			{
				Append(value.AsSpan(startIndex, count));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(char[] value, int startIndex, int charCount)
		{
			if (buffer.Length - index < charCount)
			{
				Grow(charCount);
			}
			Array.Copy(value, startIndex, buffer, index, charCount);
			index += charCount;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ReadOnlySpan<char> value)
		{
			if (buffer.Length - index < value.Length)
			{
				Grow(value.Length);
			}
			value.CopyTo(buffer.AsSpan(index));
			index += value.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ReadOnlySpan<char> value)
		{
			Append(value);
			AppendLine();
		}

		public void Append<T>(T value)
		{
			if (!FormatterCache<T>.TryFormatDelegate(value, buffer.AsSpan(index), out var charsWritten, default(ReadOnlySpan<char>)))
			{
				Grow(charsWritten);
				if (!FormatterCache<T>.TryFormatDelegate(value, buffer.AsSpan(index), out charsWritten, default(ReadOnlySpan<char>)))
				{
					ThrowArgumentException("value");
				}
			}
			index += charsWritten;
		}

		public void AppendLine<T>(T value)
		{
			Append(value);
			AppendLine();
		}

		public void Insert(int index, string value, int count)
		{
			Insert(index, value.AsSpan(), count);
		}

		public void Insert(int index, string value)
		{
			Insert(index, value.AsSpan(), 1);
		}

		public void Insert(int index, ReadOnlySpan<char> value, int count)
		{
			if (count < 0)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("count");
			}
			int length = Length;
			if ((uint)index > (uint)length)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("index");
			}
			if (value.Length != 0 && count != 0)
			{
				int val = index + value.Length * count;
				char[] array = ArrayPool<char>.Shared.Rent(Math.Max(32768, val));
				buffer.AsSpan(0, index).CopyTo(array);
				int num = index;
				for (int i = 0; i < count; i++)
				{
					value.CopyTo(array.AsSpan(num));
					num += value.Length;
				}
				int num2 = this.index - index;
				buffer.AsSpan(index, num2).CopyTo(array.AsSpan(num));
				if (buffer.Length != 31111 && buffer != null)
				{
					ArrayPool<char>.Shared.Return(buffer);
				}
				buffer = array;
				this.index = num + num2;
			}
		}

		public void Replace(char oldChar, char newChar)
		{
			Replace(oldChar, newChar, 0, Length);
		}

		public void Replace(char oldChar, char newChar, int startIndex, int count)
		{
			int length = Length;
			if ((uint)startIndex > (uint)length)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("startIndex");
			}
			if (count < 0 || startIndex > length - count)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("count");
			}
			int num = startIndex + count;
			for (int i = startIndex; i < num; i++)
			{
				if (buffer[i] == oldChar)
				{
					buffer[i] = newChar;
				}
			}
		}

		public void Replace(string oldValue, string newValue)
		{
			Replace(oldValue, newValue, 0, Length);
		}

		public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue)
		{
			Replace(oldValue, newValue, 0, Length);
		}

		public void Replace(string oldValue, string newValue, int startIndex, int count)
		{
			if (oldValue == null)
			{
				throw new ArgumentNullException("oldValue");
			}
			Replace(oldValue.AsSpan(), newValue.AsSpan(), startIndex, count);
		}

		public void Replace(ReadOnlySpan<char> oldValue, ReadOnlySpan<char> newValue, int startIndex, int count)
		{
			int length = Length;
			if ((uint)startIndex > (uint)length)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("startIndex");
			}
			if (count < 0 || startIndex > length - count)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("count");
			}
			if (oldValue.Length == 0)
			{
				throw new ArgumentException("oldValue.Length is 0", "oldValue");
			}
			ReadOnlySpan<char> readOnlySpan = AsSpan();
			int num = startIndex + count;
			int num2 = 0;
			int num3;
			for (num3 = startIndex; num3 < num; num3 += oldValue.Length)
			{
				int num4 = readOnlySpan.Slice(num3, num - num3).IndexOf(oldValue, StringComparison.Ordinal);
				if (num4 == -1)
				{
					break;
				}
				num3 += num4;
				num2++;
			}
			if (num2 == 0)
			{
				return;
			}
			char[] array = ArrayPool<char>.Shared.Rent(Math.Max(32768, Length + (newValue.Length - oldValue.Length) * num2));
			buffer.AsSpan(0, startIndex).CopyTo(array);
			int num5 = startIndex;
			int num6;
			for (num6 = startIndex; num6 < num; num6 += oldValue.Length)
			{
				int num7 = readOnlySpan.Slice(num6, num - num6).IndexOf(oldValue, StringComparison.Ordinal);
				if (num7 == -1)
				{
					ReadOnlySpan<char> readOnlySpan2 = readOnlySpan.Slice(num6);
					readOnlySpan2.CopyTo(array.AsSpan(num5));
					num5 += readOnlySpan2.Length;
					break;
				}
				readOnlySpan.Slice(num6, num7).CopyTo(array.AsSpan(num5));
				newValue.CopyTo(array.AsSpan(num5 + num7));
				num5 += num7 + newValue.Length;
				num6 += num7;
			}
			if (buffer.Length != 31111)
			{
				ArrayPool<char>.Shared.Return(buffer);
			}
			buffer = array;
			index = num5;
		}

		public void ReplaceAt(char newChar, int replaceIndex)
		{
			int length = Length;
			if ((uint)replaceIndex > (uint)length)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("replaceIndex");
			}
			buffer[replaceIndex] = newChar;
		}

		public void Remove(int startIndex, int length)
		{
			if (length < 0)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("length");
			}
			if (startIndex < 0)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("startIndex");
			}
			if (length > Length - startIndex)
			{
				ExceptionUtil.ThrowArgumentOutOfRangeException("length");
			}
			if (Length == length && startIndex == 0)
			{
				index = 0;
			}
			else if (length != 0)
			{
				int num = startIndex + length;
				buffer.AsSpan(num, Length - num).CopyTo(buffer.AsSpan(startIndex));
				index -= length;
			}
		}

		public bool TryCopyTo(Span<char> destination, out int charsWritten)
		{
			if (destination.Length < index)
			{
				charsWritten = 0;
				return false;
			}
			charsWritten = index;
			buffer.AsSpan(0, index).CopyTo(destination);
			return true;
		}

		public override string ToString()
		{
			if (index == 0)
			{
				return string.Empty;
			}
			return new string(buffer, 0, index);
		}

		public Memory<char> GetMemory(int sizeHint)
		{
			if (buffer.Length - index < sizeHint)
			{
				Grow(sizeHint);
			}
			return buffer.AsMemory(index);
		}

		public Span<char> GetSpan(int sizeHint)
		{
			if (buffer.Length - index < sizeHint)
			{
				Grow(sizeHint);
			}
			return buffer.AsSpan(index);
		}

		public void Advance(int count)
		{
			index += count;
		}

		void IResettableBufferWriter<char>.Reset()
		{
			index = 0;
		}

		private void ThrowArgumentException(string paramName)
		{
			throw new ArgumentException("Can't format argument.", paramName);
		}

		private static void ThrowFormatException()
		{
			throw new FormatException("Index (zero based) must be greater than or equal to zero and less than the size of the argument list.");
		}

		private void AppendFormatInternal<T>(T arg, int width, ReadOnlySpan<char> format, string argName)
		{
			if (width <= 0)
			{
				width *= -1;
				if (!FormatterCache<T>.TryFormatDelegate(arg, buffer.AsSpan(index), out var charsWritten, format))
				{
					Grow(charsWritten);
					if (!FormatterCache<T>.TryFormatDelegate(arg, buffer.AsSpan(index), out charsWritten, format))
					{
						ThrowArgumentException(argName);
					}
				}
				index += charsWritten;
				int num = width - charsWritten;
				if (width > 0 && num > 0)
				{
					Append(' ', num);
				}
				return;
			}
			if (typeof(T) == typeof(string))
			{
				string text = Unsafe.As<string>(arg);
				int num2 = width - text.Length;
				if (num2 > 0)
				{
					Append(' ', num2);
				}
				Append(text);
				return;
			}
			Span<char> destination = stackalloc char[typeof(T).IsValueType ? (Unsafe.SizeOf<T>() * 8) : 1024];
			if (!FormatterCache<T>.TryFormatDelegate(arg, destination, out var charsWritten2, format))
			{
				destination = stackalloc char[destination.Length * 2];
				if (!FormatterCache<T>.TryFormatDelegate(arg, destination, out charsWritten2, format))
				{
					ThrowArgumentException(argName);
				}
			}
			int num3 = width - charsWritten2;
			if (num3 > 0)
			{
				Append(' ', num3);
			}
			Append((ReadOnlySpan<char>)destination.Slice(0, charsWritten2));
		}

		private static void ThrowNestedException()
		{
			throw new NestedStringBuilderCreationException("Utf16ValueStringBuilder");
		}

		public static void RegisterTryFormat<T>(TryFormat<T> formatMethod)
		{
			FormatterCache<T>.TryFormatDelegate = formatMethod;
		}

		private static TryFormat<T?> CreateNullableFormatter<T>() where T : struct
		{
			return delegate(T? x, Span<char> dest, out int written, ReadOnlySpan<char> format)
			{
				if (!x.HasValue)
				{
					written = 0;
					return true;
				}
				return FormatterCache<T>.TryFormatDelegate(x.Value, dest, out written, format);
			};
		}

		public static void EnableNullableFormat<T>() where T : struct
		{
			RegisterTryFormat(CreateNullableFormatter<T>());
		}
	}
	public struct Utf8ValueStringBuilder : IDisposable, IBufferWriter<byte>, IResettableBufferWriter<byte>
	{
		public delegate bool TryFormat<T>(T value, Span<byte> destination, out int written, StandardFormat format);

		public static class FormatterCache<T>
		{
			public static TryFormat<T> TryFormatDelegate;

			static FormatterCache()
			{
				TryFormat<T> tryFormat = (TryFormat<T>)CreateFormatter(typeof(T));
				if (tryFormat == null)
				{
					tryFormat = ((!typeof(T).IsEnum) ? new TryFormat<T>(TryFormatDefault) : new TryFormat<T>(EnumUtil<T>.TryFormatUtf8));
				}
				TryFormatDelegate = tryFormat;
			}

			private static bool TryFormatDefault(T value, Span<byte> dest, out int written, StandardFormat format)
			{
				if (value == null)
				{
					written = 0;
					return true;
				}
				string text = ((typeof(T) == typeof(string)) ? Unsafe.As<string>(value) : (((object)value is IFormattable formattable && format != default(StandardFormat)) ? formattable.ToString(format.ToString(), null) : value.ToString()));
				written = UTF8NoBom.GetMaxByteCount(text.Length);
				if (dest.Length < written)
				{
					return false;
				}
				written = UTF8NoBom.GetBytes(text.AsSpan(), dest);
				return true;
			}
		}

		private const int ThreadStaticBufferSize = 64444;

		private const int DefaultBufferSize = 65536;

		private static Encoding UTF8NoBom;

		private static byte newLine1;

		private static byte newLine2;

		private static bool crlf;

		[ThreadStatic]
		private static byte[]? scratchBuffer;

		[ThreadStatic]
		internal static bool scratchBufferUsed;

		private byte[]? buffer;

		private int index;

		private bool disposeImmediately;

		public int Length => index;

		public void AppendJoin<T>(char separator, params T[] values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal<T>(separator2, values.AsSpan());
		}

		public void AppendJoin<T>(char separator, List<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, (IReadOnlyList<T>)values);
		}

		public void AppendJoin<T>(char separator, ReadOnlySpan<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, IEnumerable<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, ICollection<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values.AsEnumerable());
		}

		public void AppendJoin<T>(char separator, IList<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, IReadOnlyList<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values);
		}

		public void AppendJoin<T>(char separator, IReadOnlyCollection<T> values)
		{
			ReadOnlySpan<char> separator2 = stackalloc char[1] { separator };
			AppendJoinInternal(separator2, values.AsEnumerable());
		}

		public void AppendJoin<T>(string separator, params T[] values)
		{
			AppendJoinInternal<T>(separator.AsSpan(), values.AsSpan());
		}

		public void AppendJoin<T>(string separator, List<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), (IReadOnlyList<T>)values);
		}

		public void AppendJoin<T>(string separator, ReadOnlySpan<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, IEnumerable<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, ICollection<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values.AsEnumerable());
		}

		public void AppendJoin<T>(string separator, IList<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, IReadOnlyList<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values);
		}

		public void AppendJoin<T>(string separator, IReadOnlyCollection<T> values)
		{
			AppendJoinInternal(separator.AsSpan(), values.AsEnumerable());
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, IList<T> values)
		{
			IReadOnlyList<T> readOnlyList = values as IReadOnlyList<T>;
			readOnlyList = (IReadOnlyList<T>)(readOnlyList ?? ((object)new ReadOnlyListAdaptor<T>(values)));
			AppendJoinInternal(separator, readOnlyList);
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, IReadOnlyList<T> values)
		{
			int count = values.Count;
			for (int i = 0; i < count; i++)
			{
				if (i != 0)
				{
					Append(separator);
				}
				T val = values[i];
				if (typeof(T) == typeof(string))
				{
					string value = Unsafe.As<string>(val);
					if (!string.IsNullOrEmpty(value))
					{
						Append(value);
					}
				}
				else
				{
					Append(val);
				}
			}
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, ReadOnlySpan<T> values)
		{
			for (int i = 0; i < values.Length; i++)
			{
				if (i != 0)
				{
					Append(separator);
				}
				T val = values[i];
				if (typeof(T) == typeof(string))
				{
					string value = Unsafe.As<string>(val);
					if (!string.IsNullOrEmpty(value))
					{
						Append(value);
					}
				}
				else
				{
					Append(val);
				}
			}
		}

		internal void AppendJoinInternal<T>(ReadOnlySpan<char> separator, IEnumerable<T> values)
		{
			bool flag = true;
			foreach (T value2 in values)
			{
				if (!flag)
				{
					Append(separator);
				}
				else
				{
					flag = false;
				}
				if (typeof(T) == typeof(string))
				{
					string value = Unsafe.As<string>(value2);
					if (!string.IsNullOrEmpty(value))
					{
						Append(value);
					}
				}
				else
				{
					Append(value2);
				}
			}
		}

		public void AppendFormat<T1>(string format, T1 arg1)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					if (parseResult.Index == 0)
					{
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2>(string format, T1 arg1, T2 arg2)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3>(string format, T1 arg1, T2 arg2, T3 arg3)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, format2, "arg10");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, format2, "arg11");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, format2, "arg12");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, format2, "arg13");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, format2, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, format2, "arg14");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, format2, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, format2, "arg14");
						break;
					case 14:
						AppendFormatInternal(arg15, parseResult.Alignment, format2, "arg15");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		public void AppendFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int count2 = i - num;
						Append(format, num, count2);
						i++;
						num = i;
						break;
					}
					int length = i - num;
					Append(format.AsSpan(num, length));
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						AppendFormatInternal(arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						AppendFormatInternal(arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						AppendFormatInternal(arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						AppendFormatInternal(arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						AppendFormatInternal(arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						AppendFormatInternal(arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						AppendFormatInternal(arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						AppendFormatInternal(arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						AppendFormatInternal(arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						AppendFormatInternal(arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						AppendFormatInternal(arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						AppendFormatInternal(arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						AppendFormatInternal(arg13, parseResult.Alignment, format2, "arg13");
						break;
					case 13:
						AppendFormatInternal(arg14, parseResult.Alignment, format2, "arg14");
						break;
					case 14:
						AppendFormatInternal(arg15, parseResult.Alignment, format2, "arg15");
						break;
					case 15:
						AppendFormatInternal(arg16, parseResult.Alignment, format2, "arg16");
						break;
					default:
						ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int count = i - num;
						Append(format, num, count);
						i++;
						num = i;
					}
					else
					{
						ThrowFormatException();
					}
					break;
				}
			}
			int num2 = format.Length - num;
			if (num2 > 0)
			{
				Append(format, num, num2);
			}
		}

		private static object? CreateFormatter(Type type)
		{
			if (type == typeof(byte))
			{
				return (TryFormat<byte>)delegate(byte x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(DateTime))
			{
				return (TryFormat<DateTime>)delegate(DateTime x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(DateTimeOffset))
			{
				return (TryFormat<DateTimeOffset>)delegate(DateTimeOffset x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(decimal))
			{
				return (TryFormat<decimal>)delegate(decimal x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(double))
			{
				return (TryFormat<double>)delegate(double x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(short))
			{
				return (TryFormat<short>)delegate(short x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(int))
			{
				return (TryFormat<int>)delegate(int x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(long))
			{
				return (TryFormat<long>)delegate(long x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(sbyte))
			{
				return (TryFormat<sbyte>)delegate(sbyte x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(float))
			{
				return (TryFormat<float>)delegate(float x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(TimeSpan))
			{
				return (TryFormat<TimeSpan>)delegate(TimeSpan x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(ushort))
			{
				return (TryFormat<ushort>)delegate(ushort x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(uint))
			{
				return (TryFormat<uint>)delegate(uint x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(ulong))
			{
				return (TryFormat<ulong>)delegate(ulong x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(Guid))
			{
				return (TryFormat<Guid>)delegate(Guid x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(bool))
			{
				return (TryFormat<bool>)delegate(bool x, Span<byte> dest, out int written, StandardFormat format)
				{
					return Utf8Formatter.TryFormat(x, dest, out written, format);
				};
			}
			if (type == typeof(byte?))
			{
				return CreateNullableFormatter<byte>();
			}
			if (type == typeof(DateTime?))
			{
				return CreateNullableFormatter<DateTime>();
			}
			if (type == typeof(DateTimeOffset?))
			{
				return CreateNullableFormatter<DateTimeOffset>();
			}
			if (type == typeof(decimal?))
			{
				return CreateNullableFormatter<decimal>();
			}
			if (type == typeof(double?))
			{
				return CreateNullableFormatter<double>();
			}
			if (type == typeof(short?))
			{
				return CreateNullableFormatter<short>();
			}
			if (type == typeof(int?))
			{
				return CreateNullableFormatter<int>();
			}
			if (type == typeof(long?))
			{
				return CreateNullableFormatter<long>();
			}
			if (type == typeof(sbyte?))
			{
				return CreateNullableFormatter<sbyte>();
			}
			if (type == typeof(float?))
			{
				return CreateNullableFormatter<float>();
			}
			if (type == typeof(TimeSpan?))
			{
				return CreateNullableFormatter<TimeSpan>();
			}
			if (type == typeof(ushort?))
			{
				return CreateNullableFormatter<ushort>();
			}
			if (type == typeof(uint?))
			{
				return CreateNullableFormatter<uint>();
			}
			if (type == typeof(ulong?))
			{
				return CreateNullableFormatter<ulong>();
			}
			if (type == typeof(Guid?))
			{
				return CreateNullableFormatter<Guid>();
			}
			if (type == typeof(bool?))
			{
				return CreateNullableFormatter<bool>();
			}
			if (type == typeof(IntPtr))
			{
				return (TryFormat<IntPtr>)delegate(IntPtr x, Span<byte> dest, out int written, StandardFormat format)
				{
					return (IntPtr.Size != 4) ? Utf8Formatter.TryFormat(x.ToInt64(), dest, out written, format) : Utf8Formatter.TryFormat(x.ToInt32(), dest, out written, format);
				};
			}
			if (type == typeof(UIntPtr))
			{
				return (TryFormat<UIntPtr>)delegate(UIntPtr x, Span<byte> dest, out int written, StandardFormat format)
				{
					return (UIntPtr.Size != 4) ? Utf8Formatter.TryFormat(x.ToUInt64(), dest, out written, format) : Utf8Formatter.TryFormat(x.ToUInt32(), dest, out written, format);
				};
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(byte value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(byte value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(byte value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(byte value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTime value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTime value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTime value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTime value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTimeOffset value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(DateTimeOffset value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTimeOffset value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(DateTimeOffset value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(decimal value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(decimal value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(decimal value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(decimal value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(double value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(double value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(double value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(double value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(short value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(short value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(short value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(short value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(int value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(int value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(int value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(int value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(long value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(long value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(long value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(long value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(sbyte value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(sbyte value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(sbyte value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(sbyte value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(float value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(float value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(float value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(float value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(TimeSpan value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(TimeSpan value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(TimeSpan value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(TimeSpan value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ushort value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ushort value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ushort value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ushort value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(uint value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(uint value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(uint value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(uint value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ulong value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ulong value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ulong value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ulong value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(Guid value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(Guid value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(Guid value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(Guid value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(bool value)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(bool value, StandardFormat format)
		{
			if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out var bytesWritten, format))
			{
				Grow(bytesWritten);
				if (!Utf8Formatter.TryFormat(value, buffer.AsSpan(index), out bytesWritten, format))
				{
					ThrowArgumentException("value");
				}
			}
			index += bytesWritten;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(bool value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(bool value, StandardFormat format)
		{
			Append(value, format);
			AppendLine();
		}

		static Utf8ValueStringBuilder()
		{
			UTF8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);
			byte[] bytes = UTF8NoBom.GetBytes(Environment.NewLine);
			if (bytes.Length == 1)
			{
				newLine1 = bytes[0];
				crlf = false;
			}
			else
			{
				newLine1 = bytes[0];
				newLine2 = bytes[1];
				crlf = true;
			}
		}

		public ReadOnlySpan<byte> AsSpan()
		{
			return buffer.AsSpan(0, index);
		}

		public ReadOnlyMemory<byte> AsMemory()
		{
			return buffer.AsMemory(0, index);
		}

		public ArraySegment<byte> AsArraySegment()
		{
			return new ArraySegment<byte>(buffer, 0, index);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Utf8ValueStringBuilder(bool disposeImmediately)
		{
			if (disposeImmediately && scratchBufferUsed)
			{
				ThrowNestedException();
			}
			byte[] array;
			if (disposeImmediately)
			{
				array = scratchBuffer;
				if (array == null)
				{
					array = (scratchBuffer = new byte[64444]);
				}
				scratchBufferUsed = true;
			}
			else
			{
				array = ArrayPool<byte>.Shared.Rent(65536);
			}
			buffer = array;
			index = 0;
			this.disposeImmediately = disposeImmediately;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Dispose()
		{
			if (buffer != null)
			{
				if (buffer.Length != 64444)
				{
					ArrayPool<byte>.Shared.Return(buffer);
				}
				buffer = null;
				index = 0;
				if (disposeImmediately)
				{
					scratchBufferUsed = false;
				}
			}
		}

		public void Clear()
		{
			index = 0;
		}

		public void TryGrow(int sizeHint)
		{
			if (buffer.Length < index + sizeHint)
			{
				Grow(sizeHint);
			}
		}

		public void Grow(int sizeHint)
		{
			int num = buffer.Length * 2;
			if (sizeHint != 0)
			{
				num = Math.Max(num, index + sizeHint);
			}
			byte[] array = ArrayPool<byte>.Shared.Rent(num);
			buffer.CopyTo(array, 0);
			if (buffer.Length != 64444)
			{
				ArrayPool<byte>.Shared.Return(buffer);
			}
			buffer = array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine()
		{
			if (crlf)
			{
				if (buffer.Length - index < 2)
				{
					Grow(2);
				}
				buffer[index] = newLine1;
				buffer[index + 1] = newLine2;
				index += 2;
			}
			else
			{
				if (buffer.Length - index < 1)
				{
					Grow(1);
				}
				buffer[index] = newLine1;
				index++;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe void Append(char value)
		{
			int maxByteCount = UTF8NoBom.GetMaxByteCount(1);
			if (buffer.Length - index < maxByteCount)
			{
				Grow(maxByteCount);
			}
			fixed (byte* bytes = &buffer[index])
			{
				index += UTF8NoBom.GetBytes(&value, 1, bytes, maxByteCount);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(char value, int repeatCount)
		{
			if (repeatCount < 0)
			{
				throw new ArgumentOutOfRangeException("repeatCount");
			}
			if (value <= '\u007f')
			{
				GetSpan(repeatCount).Fill((byte)value);
				Advance(repeatCount);
				return;
			}
			Span<byte> bytes = stackalloc byte[UTF8NoBom.GetMaxByteCount(1)];
			ReadOnlySpan<char> chars = stackalloc char[1] { value };
			int bytes2 = UTF8NoBom.GetBytes(chars, bytes);
			TryGrow(bytes2 * repeatCount);
			for (int i = 0; i < repeatCount; i++)
			{
				bytes.CopyTo(GetSpan(bytes2));
				Advance(bytes2);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(char value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(string value, int startIndex, int count)
		{
			if (value == null)
			{
				if (startIndex != 0 || count != 0)
				{
					throw new ArgumentNullException("value");
				}
			}
			else
			{
				Append(value.AsSpan(startIndex, count));
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(string value)
		{
			Append(value.AsSpan());
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(string value)
		{
			Append(value);
			AppendLine();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Append(ReadOnlySpan<char> value)
		{
			int maxByteCount = UTF8NoBom.GetMaxByteCount(value.Length);
			if (buffer.Length - index < maxByteCount)
			{
				Grow(maxByteCount);
			}
			index += UTF8NoBom.GetBytes(value, buffer.AsSpan(index));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendLine(ReadOnlySpan<char> value)
		{
			Append(value);
			AppendLine();
		}

		public void AppendLiteral(ReadOnlySpan<byte> value)
		{
			if (buffer.Length - index < value.Length)
			{
				Grow(value.Length);
			}
			value.CopyTo(buffer.AsSpan(index));
			index += value.Length;
		}

		public void Append<T>(T value)
		{
			if (!FormatterCache<T>.TryFormatDelegate(value, buffer.AsSpan(index), out var written, default(StandardFormat)))
			{
				Grow(written);
				if (!FormatterCache<T>.TryFormatDelegate(value, buffer.AsSpan(index), out written, default(StandardFormat)))
				{
					ThrowArgumentException("value");
				}
			}
			index += written;
		}

		public void AppendLine<T>(T value)
		{
			Append(value);
			AppendLine();
		}

		public void CopyTo(IBufferWriter<byte> bufferWriter)
		{
			Span<byte> span = bufferWriter.GetSpan(index);
			TryCopyTo(span, out var bytesWritten);
			bufferWriter.Advance(bytesWritten);
		}

		public bool TryCopyTo(Span<byte> destination, out int bytesWritten)
		{
			if (destination.Length < index)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = index;
			buffer.AsSpan(0, index).CopyTo(destination);
			return true;
		}

		public Task WriteToAsync(Stream stream)
		{
			return stream.WriteAsync(buffer, 0, index);
		}

		public Task WriteToAsync(Stream stream, CancellationToken cancellationToken)
		{
			return stream.WriteAsync(buffer, 0, index, cancellationToken);
		}

		public override string ToString()
		{
			if (index == 0)
			{
				return string.Empty;
			}
			return UTF8NoBom.GetString(buffer, 0, index);
		}

		public Memory<byte> GetMemory(int sizeHint)
		{
			if (buffer.Length - index < sizeHint)
			{
				Grow(sizeHint);
			}
			return buffer.AsMemory(index);
		}

		public Span<byte> GetSpan(int sizeHint)
		{
			if (buffer.Length - index < sizeHint)
			{
				Grow(sizeHint);
			}
			return buffer.AsSpan(index);
		}

		public void Advance(int count)
		{
			index += count;
		}

		void IResettableBufferWriter<byte>.Reset()
		{
			index = 0;
		}

		private void ThrowArgumentException(string paramName)
		{
			throw new ArgumentException("Can't format argument.", paramName);
		}

		private void ThrowFormatException()
		{
			throw new FormatException("Index (zero based) must be greater than or equal to zero and less than the size of the argument list.");
		}

		private static void ThrowNestedException()
		{
			throw new NestedStringBuilderCreationException("Utf8ValueStringBuilder");
		}

		private void AppendFormatInternal<T>(T arg, int width, StandardFormat format, string argName)
		{
			if (width <= 0)
			{
				width *= -1;
				if (!FormatterCache<T>.TryFormatDelegate(arg, buffer.AsSpan(index), out var written, format))
				{
					Grow(written);
					if (!FormatterCache<T>.TryFormatDelegate(arg, buffer.AsSpan(index), out written, format))
					{
						ThrowArgumentException(argName);
					}
				}
				index += written;
				int num = width - written;
				if (width > 0 && num > 0)
				{
					Append(' ', num);
				}
				return;
			}
			if (typeof(T) == typeof(string))
			{
				string text = Unsafe.As<string>(arg);
				int num2 = width - text.Length;
				if (num2 > 0)
				{
					Append(' ', num2);
				}
				Append(text);
				return;
			}
			Span<byte> destination = stackalloc byte[typeof(T).IsValueType ? (Unsafe.SizeOf<T>() * 8) : 1024];
			if (!FormatterCache<T>.TryFormatDelegate(arg, destination, out var written2, format))
			{
				destination = stackalloc byte[destination.Length * 2];
				if (!FormatterCache<T>.TryFormatDelegate(arg, destination, out written2, format))
				{
					ThrowArgumentException(argName);
				}
			}
			int num3 = width - written2;
			if (num3 > 0)
			{
				Append(' ', num3);
			}
			destination.CopyTo(GetSpan(written2));
			Advance(written2);
		}

		public static void RegisterTryFormat<T>(TryFormat<T> formatMethod)
		{
			FormatterCache<T>.TryFormatDelegate = formatMethod;
		}

		private static TryFormat<T?> CreateNullableFormatter<T>() where T : struct
		{
			return delegate(T? x, Span<byte> destination, out int written, StandardFormat format)
			{
				if (!x.HasValue)
				{
					written = 0;
					return true;
				}
				return FormatterCache<T>.TryFormatDelegate(x.Value, destination, out written, format);
			};
		}

		public static void EnableNullableFormat<T>() where T : struct
		{
			RegisterTryFormat(CreateNullableFormatter<T>());
		}
	}
	public static class ZString
	{
		private static Encoding UTF8NoBom = new UTF8Encoding(encoderShouldEmitUTF8Identifier: false);

		public static string Concat<T1>(T1 arg1)
		{
			if (typeof(T1) == typeof(string))
			{
				if (arg1 == null)
				{
					return string.Empty;
				}
				return Unsafe.As<string>(arg1);
			}
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2>(T1 arg1, T2 arg2)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3>(T1 arg1, T2 arg2, T3 arg3)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				if (typeof(T10) == typeof(string))
				{
					if (arg10 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T10, string>(ref arg10));
					}
				}
				else if (typeof(T10) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T10, int>(ref arg10));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg10);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				if (typeof(T10) == typeof(string))
				{
					if (arg10 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T10, string>(ref arg10));
					}
				}
				else if (typeof(T10) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T10, int>(ref arg10));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg10);
				}
				if (typeof(T11) == typeof(string))
				{
					if (arg11 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T11, string>(ref arg11));
					}
				}
				else if (typeof(T11) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T11, int>(ref arg11));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg11);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				if (typeof(T10) == typeof(string))
				{
					if (arg10 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T10, string>(ref arg10));
					}
				}
				else if (typeof(T10) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T10, int>(ref arg10));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg10);
				}
				if (typeof(T11) == typeof(string))
				{
					if (arg11 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T11, string>(ref arg11));
					}
				}
				else if (typeof(T11) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T11, int>(ref arg11));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg11);
				}
				if (typeof(T12) == typeof(string))
				{
					if (arg12 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T12, string>(ref arg12));
					}
				}
				else if (typeof(T12) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T12, int>(ref arg12));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg12);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				if (typeof(T10) == typeof(string))
				{
					if (arg10 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T10, string>(ref arg10));
					}
				}
				else if (typeof(T10) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T10, int>(ref arg10));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg10);
				}
				if (typeof(T11) == typeof(string))
				{
					if (arg11 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T11, string>(ref arg11));
					}
				}
				else if (typeof(T11) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T11, int>(ref arg11));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg11);
				}
				if (typeof(T12) == typeof(string))
				{
					if (arg12 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T12, string>(ref arg12));
					}
				}
				else if (typeof(T12) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T12, int>(ref arg12));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg12);
				}
				if (typeof(T13) == typeof(string))
				{
					if (arg13 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T13, string>(ref arg13));
					}
				}
				else if (typeof(T13) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T13, int>(ref arg13));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg13);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				if (typeof(T10) == typeof(string))
				{
					if (arg10 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T10, string>(ref arg10));
					}
				}
				else if (typeof(T10) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T10, int>(ref arg10));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg10);
				}
				if (typeof(T11) == typeof(string))
				{
					if (arg11 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T11, string>(ref arg11));
					}
				}
				else if (typeof(T11) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T11, int>(ref arg11));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg11);
				}
				if (typeof(T12) == typeof(string))
				{
					if (arg12 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T12, string>(ref arg12));
					}
				}
				else if (typeof(T12) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T12, int>(ref arg12));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg12);
				}
				if (typeof(T13) == typeof(string))
				{
					if (arg13 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T13, string>(ref arg13));
					}
				}
				else if (typeof(T13) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T13, int>(ref arg13));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg13);
				}
				if (typeof(T14) == typeof(string))
				{
					if (arg14 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T14, string>(ref arg14));
					}
				}
				else if (typeof(T14) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T14, int>(ref arg14));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg14);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				if (typeof(T10) == typeof(string))
				{
					if (arg10 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T10, string>(ref arg10));
					}
				}
				else if (typeof(T10) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T10, int>(ref arg10));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg10);
				}
				if (typeof(T11) == typeof(string))
				{
					if (arg11 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T11, string>(ref arg11));
					}
				}
				else if (typeof(T11) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T11, int>(ref arg11));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg11);
				}
				if (typeof(T12) == typeof(string))
				{
					if (arg12 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T12, string>(ref arg12));
					}
				}
				else if (typeof(T12) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T12, int>(ref arg12));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg12);
				}
				if (typeof(T13) == typeof(string))
				{
					if (arg13 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T13, string>(ref arg13));
					}
				}
				else if (typeof(T13) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T13, int>(ref arg13));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg13);
				}
				if (typeof(T14) == typeof(string))
				{
					if (arg14 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T14, string>(ref arg14));
					}
				}
				else if (typeof(T14) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T14, int>(ref arg14));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg14);
				}
				if (typeof(T15) == typeof(string))
				{
					if (arg15 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T15, string>(ref arg15));
					}
				}
				else if (typeof(T15) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T15, int>(ref arg15));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg15);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static string Concat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				if (typeof(T1) == typeof(string))
				{
					if (arg1 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T1, string>(ref arg1));
					}
				}
				else if (typeof(T1) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T1, int>(ref arg1));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg1);
				}
				if (typeof(T2) == typeof(string))
				{
					if (arg2 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T2, string>(ref arg2));
					}
				}
				else if (typeof(T2) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T2, int>(ref arg2));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg2);
				}
				if (typeof(T3) == typeof(string))
				{
					if (arg3 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T3, string>(ref arg3));
					}
				}
				else if (typeof(T3) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T3, int>(ref arg3));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg3);
				}
				if (typeof(T4) == typeof(string))
				{
					if (arg4 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T4, string>(ref arg4));
					}
				}
				else if (typeof(T4) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T4, int>(ref arg4));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg4);
				}
				if (typeof(T5) == typeof(string))
				{
					if (arg5 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T5, string>(ref arg5));
					}
				}
				else if (typeof(T5) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T5, int>(ref arg5));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg5);
				}
				if (typeof(T6) == typeof(string))
				{
					if (arg6 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T6, string>(ref arg6));
					}
				}
				else if (typeof(T6) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T6, int>(ref arg6));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg6);
				}
				if (typeof(T7) == typeof(string))
				{
					if (arg7 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T7, string>(ref arg7));
					}
				}
				else if (typeof(T7) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T7, int>(ref arg7));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg7);
				}
				if (typeof(T8) == typeof(string))
				{
					if (arg8 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T8, string>(ref arg8));
					}
				}
				else if (typeof(T8) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T8, int>(ref arg8));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg8);
				}
				if (typeof(T9) == typeof(string))
				{
					if (arg9 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T9, string>(ref arg9));
					}
				}
				else if (typeof(T9) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T9, int>(ref arg9));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg9);
				}
				if (typeof(T10) == typeof(string))
				{
					if (arg10 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T10, string>(ref arg10));
					}
				}
				else if (typeof(T10) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T10, int>(ref arg10));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg10);
				}
				if (typeof(T11) == typeof(string))
				{
					if (arg11 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T11, string>(ref arg11));
					}
				}
				else if (typeof(T11) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T11, int>(ref arg11));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg11);
				}
				if (typeof(T12) == typeof(string))
				{
					if (arg12 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T12, string>(ref arg12));
					}
				}
				else if (typeof(T12) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T12, int>(ref arg12));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg12);
				}
				if (typeof(T13) == typeof(string))
				{
					if (arg13 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T13, string>(ref arg13));
					}
				}
				else if (typeof(T13) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T13, int>(ref arg13));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg13);
				}
				if (typeof(T14) == typeof(string))
				{
					if (arg14 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T14, string>(ref arg14));
					}
				}
				else if (typeof(T14) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T14, int>(ref arg14));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg14);
				}
				if (typeof(T15) == typeof(string))
				{
					if (arg15 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T15, string>(ref arg15));
					}
				}
				else if (typeof(T15) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T15, int>(ref arg15));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg15);
				}
				if (typeof(T16) == typeof(string))
				{
					if (arg16 != null)
					{
						utf16ValueStringBuilder.Append(Unsafe.As<T16, string>(ref arg16));
					}
				}
				else if (typeof(T16) == typeof(int))
				{
					utf16ValueStringBuilder.Append(Unsafe.As<T16, int>(ref arg16));
				}
				else
				{
					utf16ValueStringBuilder.Append(arg16);
				}
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void AppendChars<TBufferWriter>(ref TBufferWriter sb, ReadOnlySpan<char> chars) where TBufferWriter : IBufferWriter<byte>
		{
			ref TBufferWriter reference = ref sb;
			TBufferWriter val = default(TBufferWriter);
			if (val == null)
			{
				val = reference;
				reference = ref val;
			}
			Span<byte> span = reference.GetSpan(UTF8NoBom.GetMaxByteCount(chars.Length));
			ref TBufferWriter reference2 = ref sb;
			val = default(TBufferWriter);
			if (val == null)
			{
				val = reference2;
				reference2 = ref val;
			}
			reference2.Advance(UTF8NoBom.GetBytes(chars, span));
		}

		public static Utf16ValueStringBuilder CreateStringBuilder()
		{
			return new Utf16ValueStringBuilder(disposeImmediately: false);
		}

		public static Utf8ValueStringBuilder CreateUtf8StringBuilder()
		{
			return new Utf8ValueStringBuilder(disposeImmediately: false);
		}

		public static Utf16ValueStringBuilder CreateStringBuilder(bool notNested)
		{
			return new Utf16ValueStringBuilder(notNested);
		}

		public static Utf8ValueStringBuilder CreateUtf8StringBuilder(bool notNested)
		{
			return new Utf8ValueStringBuilder(notNested);
		}

		public static string Join<T>(char separator, params T[] values)
		{
			return JoinInternal<T>(stackalloc char[1] { separator }, values.AsSpan());
		}

		public static string Join<T>(char separator, List<T> values)
		{
			return JoinInternal((ReadOnlySpan<char>)stackalloc char[1] { separator }, (IReadOnlyList<T>)values);
		}

		public static string Join<T>(char separator, ReadOnlySpan<T> values)
		{
			return JoinInternal(stackalloc char[1] { separator }, values);
		}

		public static string Join<T>(char separator, IEnumerable<T> values)
		{
			return JoinInternal(stackalloc char[1] { separator }, values);
		}

		public static string Join<T>(char separator, ICollection<T> values)
		{
			return JoinInternal(stackalloc char[1] { separator }, values.AsEnumerable());
		}

		public static string Join<T>(char separator, IList<T> values)
		{
			return JoinInternal(stackalloc char[1] { separator }, values);
		}

		public static string Join<T>(char separator, IReadOnlyList<T> values)
		{
			return JoinInternal(stackalloc char[1] { separator }, values);
		}

		public static string Join<T>(char separator, IReadOnlyCollection<T> values)
		{
			return JoinInternal(stackalloc char[1] { separator }, values.AsEnumerable());
		}

		public static string Join<T>(string separator, params T[] values)
		{
			return JoinInternal<T>(separator.AsSpan(), values.AsSpan());
		}

		public static string Join<T>(string separator, List<T> values)
		{
			return JoinInternal(separator.AsSpan(), (IReadOnlyList<T>)values);
		}

		public static string Join<T>(string separator, ReadOnlySpan<T> values)
		{
			return JoinInternal(separator.AsSpan(), values);
		}

		public static string Join<T>(string separator, ICollection<T> values)
		{
			return JoinInternal(separator.AsSpan(), values.AsEnumerable());
		}

		public static string Join<T>(string separator, IList<T> values)
		{
			return JoinInternal(separator.AsSpan(), values);
		}

		public static string Join<T>(string separator, IReadOnlyList<T> values)
		{
			return JoinInternal(separator.AsSpan(), values);
		}

		public static string Join<T>(string separator, IReadOnlyCollection<T> values)
		{
			return JoinInternal(separator.AsSpan(), values.AsEnumerable());
		}

		public static string Join<T>(string separator, IEnumerable<T> values)
		{
			return JoinInternal(separator.AsSpan(), values);
		}

		public static string Concat<T>(params T[] values)
		{
			return JoinInternal<T>(default(ReadOnlySpan<char>), values.AsSpan());
		}

		public static string Concat<T>(List<T> values)
		{
			return JoinInternal(default(ReadOnlySpan<char>), (IReadOnlyList<T>)values);
		}

		public static string Concat<T>(ReadOnlySpan<T> values)
		{
			return JoinInternal(default(ReadOnlySpan<char>), values);
		}

		public static string Concat<T>(ICollection<T> values)
		{
			return JoinInternal(default(ReadOnlySpan<char>), values.AsEnumerable());
		}

		public static string Concat<T>(IList<T> values)
		{
			return JoinInternal(default(ReadOnlySpan<char>), values);
		}

		public static string Concat<T>(IReadOnlyList<T> values)
		{
			return JoinInternal(default(ReadOnlySpan<char>), values);
		}

		public static string Concat<T>(IReadOnlyCollection<T> values)
		{
			return JoinInternal(default(ReadOnlySpan<char>), values.AsEnumerable());
		}

		public static string Concat<T>(IEnumerable<T> values)
		{
			return JoinInternal(default(ReadOnlySpan<char>), values);
		}

		private static string JoinInternal<T>(ReadOnlySpan<char> separator, IList<T> values)
		{
			IReadOnlyList<T> readOnlyList = values as IReadOnlyList<T>;
			readOnlyList = (IReadOnlyList<T>)(readOnlyList ?? ((object)new ReadOnlyListAdaptor<T>(values)));
			return JoinInternal(separator, readOnlyList);
		}

		private static string JoinInternal<T>(ReadOnlySpan<char> separator, IReadOnlyList<T> values)
		{
			if (values.Count == 0)
			{
				return string.Empty;
			}
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendJoinInternal(separator, values);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		private static string JoinInternal<T>(ReadOnlySpan<char> separator, ReadOnlySpan<T> values)
		{
			if (values.Length == 0)
			{
				return string.Empty;
			}
			if (typeof(T) == typeof(string) && values.Length == 1)
			{
				return Unsafe.As<string>(values[0]);
			}
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendJoinInternal(separator, values);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		private static string JoinInternal<T>(ReadOnlySpan<char> separator, IEnumerable<T> values)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendJoinInternal(separator, values);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1>(string format, T1 arg1)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1>(ReadOnlySpan<char> format, T1 arg1)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2>(string format, T1 arg1, T2 arg2)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2>(ReadOnlySpan<char> format, T1 arg1, T2 arg2)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3>(string format, T1 arg1, T2 arg2, T3 arg3)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static string Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(ReadOnlySpan<char> format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			Utf16ValueStringBuilder utf16ValueStringBuilder = new Utf16ValueStringBuilder(disposeImmediately: true);
			try
			{
				utf16ValueStringBuilder.AppendFormat(format, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16);
				return utf16ValueStringBuilder.ToString();
			}
			finally
			{
				utf16ValueStringBuilder.Dispose();
			}
		}

		public static Utf16PreparedFormat<T1> PrepareUtf16<T1>(string format)
		{
			return new Utf16PreparedFormat<T1>(format);
		}

		public static Utf8PreparedFormat<T1> PrepareUtf8<T1>(string format)
		{
			return new Utf8PreparedFormat<T1>(format);
		}

		public static Utf16PreparedFormat<T1, T2> PrepareUtf16<T1, T2>(string format)
		{
			return new Utf16PreparedFormat<T1, T2>(format);
		}

		public static Utf8PreparedFormat<T1, T2> PrepareUtf8<T1, T2>(string format)
		{
			return new Utf8PreparedFormat<T1, T2>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3> PrepareUtf16<T1, T2, T3>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3> PrepareUtf8<T1, T2, T3>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4> PrepareUtf16<T1, T2, T3, T4>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4> PrepareUtf8<T1, T2, T3, T4>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5> PrepareUtf16<T1, T2, T3, T4, T5>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5> PrepareUtf8<T1, T2, T3, T4, T5>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6> PrepareUtf16<T1, T2, T3, T4, T5, T6>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6> PrepareUtf8<T1, T2, T3, T4, T5, T6>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(format);
		}

		public static Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> PrepareUtf16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string format)
		{
			return new Utf16PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(format);
		}

		public static Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> PrepareUtf8<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(string format)
		{
			return new Utf8PreparedFormat<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(format);
		}

		public static void Utf8Format<T1>(IBufferWriter<byte> bufferWriter, string format, T1 arg1)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					if (parseResult.Index == 0)
					{
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					}
					ExceptionUtil.ThrowFormatException();
					ExceptionUtil.ThrowFormatException();
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg10, parseResult.Alignment, format2, "arg10");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg11, parseResult.Alignment, format2, "arg11");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg12, parseResult.Alignment, format2, "arg12");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg13, parseResult.Alignment, format2, "arg13");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg13, parseResult.Alignment, format2, "arg13");
						break;
					case 13:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg14, parseResult.Alignment, format2, "arg14");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg13, parseResult.Alignment, format2, "arg13");
						break;
					case 13:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg14, parseResult.Alignment, format2, "arg14");
						break;
					case 14:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg15, parseResult.Alignment, format2, "arg15");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}

		public static void Utf8Format<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>(IBufferWriter<byte> bufferWriter, string format, T1 arg1, T2 arg2, T3 arg3, T4 arg4, T5 arg5, T6 arg6, T7 arg7, T8 arg8, T9 arg9, T10 arg10, T11 arg11, T12 arg12, T13 arg13, T14 arg14, T15 arg15, T16 arg16)
		{
			if (format == null)
			{
				throw new ArgumentNullException("format");
			}
			int num = 0;
			for (int i = 0; i < format.Length; i++)
			{
				switch (format[i])
				{
				case '{':
				{
					if (i == format.Length - 1)
					{
						throw new FormatException("invalid format");
					}
					if (i != format.Length && format[i + 1] == '{')
					{
						int num3 = i - num;
						Span<byte> span2 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num3));
						int bytes2 = UTF8NoBom.GetBytes(format.AsSpan(num, num3), span2);
						bufferWriter.Advance(bytes2);
						i++;
						num = i;
						break;
					}
					int num4 = i - num;
					Span<byte> span3 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num4));
					int bytes3 = UTF8NoBom.GetBytes(format.AsSpan(num, num4), span3);
					bufferWriter.Advance(bytes3);
					FormatParser.ParseResult parseResult = FormatParser.Parse(format, i);
					num = parseResult.LastIndex;
					i = parseResult.LastIndex - 1;
					StandardFormat format2 = StandardFormat.Parse(parseResult.FormatString);
					switch (parseResult.Index)
					{
					case 0:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg1, parseResult.Alignment, format2, "arg1");
						break;
					case 1:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg2, parseResult.Alignment, format2, "arg2");
						break;
					case 2:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg3, parseResult.Alignment, format2, "arg3");
						break;
					case 3:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg4, parseResult.Alignment, format2, "arg4");
						break;
					case 4:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg5, parseResult.Alignment, format2, "arg5");
						break;
					case 5:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg6, parseResult.Alignment, format2, "arg6");
						break;
					case 6:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg7, parseResult.Alignment, format2, "arg7");
						break;
					case 7:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg8, parseResult.Alignment, format2, "arg8");
						break;
					case 8:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg9, parseResult.Alignment, format2, "arg9");
						break;
					case 9:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg10, parseResult.Alignment, format2, "arg10");
						break;
					case 10:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg11, parseResult.Alignment, format2, "arg11");
						break;
					case 11:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg12, parseResult.Alignment, format2, "arg12");
						break;
					case 12:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg13, parseResult.Alignment, format2, "arg13");
						break;
					case 13:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg14, parseResult.Alignment, format2, "arg14");
						break;
					case 14:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg15, parseResult.Alignment, format2, "arg15");
						break;
					case 15:
						Utf8FormatHelper.FormatTo(ref bufferWriter, arg16, parseResult.Alignment, format2, "arg16");
						break;
					default:
						ExceptionUtil.ThrowFormatException();
						ExceptionUtil.ThrowFormatException();
						break;
					}
					break;
				}
				case '}':
					if (i + 1 < format.Length && format[i + 1] == '}')
					{
						int num2 = i - num;
						Span<byte> span = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num2));
						int bytes = UTF8NoBom.GetBytes(format.AsSpan(num, num2), span);
						bufferWriter.Advance(bytes);
						i++;
						num = i;
					}
					else
					{
						ExceptionUtil.ThrowFormatException();
					}
					break;
				}
			}
			int num5 = format.Length - num;
			if (num5 > 0)
			{
				Span<byte> span4 = bufferWriter.GetSpan(UTF8NoBom.GetMaxByteCount(num5));
				int bytes4 = UTF8NoBom.GetBytes(format.AsSpan(num, num5), span4);
				bufferWriter.Advance(bytes4);
			}
		}
	}
	public sealed class ZStringWriter : TextWriter
	{
		private Utf16ValueStringBuilder sb;

		private bool isOpen;

		private UnicodeEncoding? encoding;

		public override Encoding Encoding
		{
			get
			{
				UnicodeEncoding? obj = encoding ?? new UnicodeEncoding(bigEndian: false, byteOrderMark: false);
				UnicodeEncoding result = obj;
				encoding = obj;
				return result;
			}
		}

		public ZStringWriter()
			: this(CultureInfo.CurrentCulture)
		{
		}

		public ZStringWriter(IFormatProvider formatProvider)
			: base(formatProvider)
		{
			sb = ZString.CreateStringBuilder();
			isOpen = true;
		}

		public override void Close()
		{
			Dispose(disposing: true);
		}

		protected override void Dispose(bool disposing)
		{
			sb.Dispose();
			isOpen = false;
			base.Dispose(disposing);
		}

		public override void Write(char value)
		{
			AssertNotDisposed();
			sb.Append(value);
		}

		public override void Write(char[] buffer, int index, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (index < 0)
			{
				throw new ArgumentOutOfRangeException("index");
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count");
			}
			if (buffer.Length - index < count)
			{
				throw new ArgumentException();
			}
			AssertNotDisposed();
			sb.Append(buffer, index, count);
		}

		public override void Write(string value)
		{
			AssertNotDisposed();
			if (value != null)
			{
				sb.Append(value);
			}
		}

		public override Task WriteAsync(char value)
		{
			Write(value);
			return Task.CompletedTask;
		}

		public override Task WriteAsync(string value)
		{
			Write(value);
			return Task.CompletedTask;
		}

		public override Task WriteAsync(char[] buffer, int index, int count)
		{
			Write(buffer, index, count);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(char value)
		{
			WriteLine(value);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(string value)
		{
			WriteLine(value);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(char[] buffer, int index, int count)
		{
			WriteLine(buffer, index, count);
			return Task.CompletedTask;
		}

		public override void Write(bool value)
		{
			AssertNotDisposed();
			sb.Append(value);
		}

		public override void Write(decimal value)
		{
			AssertNotDisposed();
			sb.Append(value);
		}

		public override Task FlushAsync()
		{
			return Task.CompletedTask;
		}

		public override string ToString()
		{
			return sb.ToString();
		}

		public override void Write(ReadOnlySpan<char> buffer)
		{
			AssertNotDisposed();
			sb.Append(buffer);
		}

		public override void WriteLine(ReadOnlySpan<char> buffer)
		{
			AssertNotDisposed();
			sb.Append(buffer);
			WriteLine();
		}

		public override Task WriteAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			Write(buffer.Span);
			return Task.CompletedTask;
		}

		public override Task WriteLineAsync(ReadOnlyMemory<char> buffer, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (cancellationToken.IsCancellationRequested)
			{
				return Task.FromCanceled(cancellationToken);
			}
			WriteLine(buffer.Span);
			return Task.CompletedTask;
		}

		private void AssertNotDisposed()
		{
			if (!isOpen)
			{
				throw new ObjectDisposedException("sb");
			}
		}
	}
}