using System;
using System.CodeDom.Compiler;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("2.5.108.51978")]
[assembly: AssemblyInformationalVersion("2.5.108+cb0ad5dd95")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.SafeDirectories)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = ".NET Standard 2.0")]
[assembly: AssemblyCompany("neuecc,aarnott")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© Yoshifumi Kawai and contributors. All rights reserved.")]
[assembly: AssemblyDescription("Attributes and interfaces for .NET types serializable with MessagePack.")]
[assembly: AssemblyProduct("MessagePack.Annotations")]
[assembly: AssemblyTitle("MessagePack.Annotations")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/neuecc/MessagePack-CSharp")]
[assembly: AssemblyVersion("2.5.0.0")]
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;
		}
	}
}
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.5.119.9565")]
[ExcludeFromCodeCoverage]
internal static class ThisAssembly
{
	internal const string AssemblyConfiguration = "Release";

	internal const string AssemblyFileVersion = "2.5.108.51978";

	internal const string AssemblyInformationalVersion = "2.5.108+cb0ad5dd95";

	internal const string AssemblyName = "MessagePack.Annotations";

	internal const string AssemblyTitle = "MessagePack.Annotations";

	internal const string AssemblyVersion = "2.5.0.0";

	internal static readonly DateTime GitCommitDate = new DateTime(638145736080000000L, DateTimeKind.Utc);

	internal const string GitCommitId = "cb0ad5dd955cb9b14ca63019938a6aada43ce822";

	internal const bool IsPrerelease = false;

	internal const bool IsPublicRelease = true;

	internal const string PublicKey = "0024000004800000940000000602000000240000525341310004000001000100293894d4e8ad2b53afbea4e949ef54c2a388b08b5ebd143c811da82f22aa20c839ed1c0b4da83e7195e8c1dbe1bf3934e4e8fd7fb93f893439106fbf055a97c7fac0f7f8c39e58e78371dc0e3825e5b9d7e2afff0372f03c4d67ff7df0dbfb58dcadeb1044840de152bf8270de7fc54255ace8efd026c16311760d1a2570c3e8";

	internal const string PublicKeyToken = "b4a0369545f0a1be";

	internal const string RootNamespace = "MessagePack";
}
namespace MessagePack
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = true)]
	public class MessagePackObjectAttribute : Attribute
	{
		public bool KeyAsPropertyName { get; private set; }

		public MessagePackObjectAttribute(bool keyAsPropertyName = false)
		{
			KeyAsPropertyName = keyAsPropertyName;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
	public class KeyAttribute : Attribute
	{
		public int? IntKey { get; private set; }

		public string? StringKey { get; private set; }

		public KeyAttribute(int x)
		{
			IntKey = x;
		}

		public KeyAttribute(string x)
		{
			StringKey = x ?? throw new ArgumentNullException("x");
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
	public class IgnoreMemberAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	public class UnionAttribute : Attribute
	{
		public int Key { get; private set; }

		public Type SubType { get; private set; }

		public UnionAttribute(int key, Type subType)
		{
			Key = key;
			SubType = subType ?? throw new ArgumentNullException("subType");
		}

		public UnionAttribute(int key, string subType)
		{
			Key = key;
			SubType = Type.GetType(subType, throwOnError: true);
		}
	}
	[AttributeUsage(AttributeTargets.Constructor, AllowMultiple = false, Inherited = true)]
	public class SerializationConstructorAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface, AllowMultiple = false, Inherited = true)]
	public class MessagePackFormatterAttribute : Attribute
	{
		public Type FormatterType { get; private set; }

		public object?[]? Arguments { get; private set; }

		public MessagePackFormatterAttribute(Type formatterType)
		{
			FormatterType = formatterType ?? throw new ArgumentNullException("formatterType");
		}

		public MessagePackFormatterAttribute(Type formatterType, params object?[]? arguments)
		{
			FormatterType = formatterType ?? throw new ArgumentNullException("formatterType");
			Arguments = arguments;
		}
	}
	public interface IMessagePackSerializationCallbackReceiver
	{
		void OnBeforeSerialize();

		void OnAfterDeserialize();
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnIfAttribute : Attribute
	{
		public bool ParameterValue { get; }

		public DoesNotReturnIfAttribute(bool parameterValue)
		{
			ParameterValue = parameterValue;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Parameter | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullIfNotNullAttribute : Attribute
	{
		public string ParameterName { get; }

		public NotNullIfNotNullAttribute(string parameterName)
		{
			ParameterName = parameterName;
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}

using System;
using System.Buffers;
using System.Buffers.Binary;
using System.Buffers.Text;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Dynamic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Numerics;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.ExceptionServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using MessagePack.Formatters;
using MessagePack.ImmutableCollection;
using MessagePack.Internal;
using MessagePack.LZ4;
using MessagePack.Resolvers;
using Microsoft.CodeAnalysis;
using Microsoft.NET.StringTools;
using Nerdbank.Streams;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyFileVersion("2.5.108.51978")]
[assembly: AssemblyInformationalVersion("2.5.108+cb0ad5dd95")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.SafeDirectories)]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("neuecc,aarnott")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyCopyright("© Yoshifumi Kawai and contributors. All rights reserved.")]
[assembly: AssemblyDescription("Extremely Fast MessagePack(MsgPack) Serializer for C# (.NET Framework, .NET 6, Unity, Xamarin).")]
[assembly: AssemblyProduct("MessagePack")]
[assembly: AssemblyTitle("MessagePack")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/neuecc/MessagePack-CSharp")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.5.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[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;
		}
	}
}
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.5.119.9565")]
[ExcludeFromCodeCoverage]
internal static class ThisAssembly
{
	internal const string AssemblyConfiguration = "Release";

	internal const string AssemblyFileVersion = "2.5.108.51978";

	internal const string AssemblyInformationalVersion = "2.5.108+cb0ad5dd95";

	internal const string AssemblyName = "MessagePack";

	internal const string AssemblyTitle = "MessagePack";

	internal const string AssemblyVersion = "2.5.0.0";

	internal static readonly DateTime GitCommitDate = new DateTime(638145736080000000L, DateTimeKind.Utc);

	internal const string GitCommitId = "cb0ad5dd955cb9b14ca63019938a6aada43ce822";

	internal const bool IsPrerelease = false;

	internal const bool IsPublicRelease = true;

	internal const string PublicKey = "0024000004800000940000000602000000240000525341310004000001000100293894d4e8ad2b53afbea4e949ef54c2a388b08b5ebd143c811da82f22aa20c839ed1c0b4da83e7195e8c1dbe1bf3934e4e8fd7fb93f893439106fbf055a97c7fac0f7f8c39e58e78371dc0e3825e5b9d7e2afff0372f03c4d67ff7df0dbfb58dcadeb1044840de152bf8270de7fc54255ace8efd026c16311760d1a2570c3e8";

	internal const string PublicKeyToken = "b4a0369545f0a1be";

	internal const string RootNamespace = "MessagePack";
}
namespace Nerdbank.Streams
{
	[DebuggerDisplay("{DebuggerDisplay,nq}")]
	internal class Sequence<T> : IBufferWriter<T>, IDisposable
	{
		private class SequenceSegment : ReadOnlySequenceSegment<T>
		{
			internal static readonly SequenceSegment Empty = new SequenceSegment();

			private static readonly bool MayContainReferences = !typeof(T).GetTypeInfo().IsPrimitive;

			private T[]? array;

			internal int Start { get; private set; }

			internal int End { get; private set; }

			internal Memory<T> RemainingMemory => AvailableMemory.Slice(End);

			internal Span<T> RemainingSpan => AvailableMemory.Span.Slice(End);

			internal IMemoryOwner<T>? MemoryOwner { get; private set; }

			internal Memory<T> AvailableMemory
			{
				get
				{
					T[] array = this.array;
					if (array == null)
					{
						return MemoryOwner?.Memory ?? default(Memory<T>);
					}
					return array;
				}
			}

			internal int Length => checked(End - Start);

			internal int WritableBytes => checked(AvailableMemory.Length - End);

			internal new SequenceSegment? Next
			{
				get
				{
					return (SequenceSegment)base.Next;
				}
				set
				{
					base.Next = value;
				}
			}

			internal bool IsForeignMemory
			{
				get
				{
					if (array == null)
					{
						return MemoryOwner == null;
					}
					return false;
				}
			}

			internal void Assign(IMemoryOwner<T> memoryOwner)
			{
				MemoryOwner = memoryOwner;
				base.Memory = memoryOwner.Memory;
			}

			internal void Assign(T[] array)
			{
				this.array = array;
				base.Memory = array;
			}

			internal void AssignForeign(ReadOnlyMemory<T> memory)
			{
				base.Memory = memory;
				End = memory.Length;
			}

			internal void ResetMemory(ArrayPool<T>? arrayPool)
			{
				ClearReferences(Start, checked(End - Start));
				base.Memory = default(ReadOnlyMemory<T>);
				Next = null;
				base.RunningIndex = 0L;
				Start = 0;
				End = 0;
				if (array != null)
				{
					arrayPool.Return(array);
					array = null;
				}
				else
				{
					MemoryOwner?.Dispose();
					MemoryOwner = null;
				}
			}

			internal void SetNext(SequenceSegment segment)
			{
				Next = segment;
				checked
				{
					segment.RunningIndex = base.RunningIndex + Start + Length;
					if (!IsForeignMemory)
					{
						base.Memory = AvailableMemory.Slice(0, Start + Length);
					}
				}
			}

			internal void Advance(int count)
			{
				checked
				{
					Requires.Range(count >= 0 && End + count <= base.Memory.Length, "count");
					End += count;
				}
			}

			internal void AdvanceTo(int offset)
			{
				ClearReferences(Start, checked(offset - Start));
				Start = offset;
			}

			private void ClearReferences(int startIndex, int length)
			{
				if (MayContainReferences)
				{
					Span<T> span = AvailableMemory.Span;
					span = span.Slice(startIndex, length);
					span.Clear();
				}
			}
		}

		private const int MaximumAutoGrowSize = 32768;

		private static readonly int DefaultLengthFromArrayPool;

		private static readonly ReadOnlySequence<T> Empty;

		private readonly Stack<SequenceSegment> segmentPool = new Stack<SequenceSegment>();

		private readonly MemoryPool<T>? memoryPool;

		private readonly ArrayPool<T>? arrayPool;

		private SequenceSegment? first;

		private SequenceSegment? last;

		public int MinimumSpanLength { get; set; }

		public bool AutoIncreaseMinimumSpanLength { get; set; } = true;


		public ReadOnlySequence<T> AsReadOnlySequence => this;

		public long Length => AsReadOnlySequence.Length;

		private string DebuggerDisplay => $"Length: {AsReadOnlySequence.Length}";

		public Sequence()
			: this(ArrayPool<T>.Create())
		{
		}

		public Sequence(MemoryPool<T> memoryPool)
		{
			Requires.NotNull(memoryPool, "memoryPool");
			this.memoryPool = memoryPool;
		}

		public Sequence(ArrayPool<T> arrayPool)
		{
			Requires.NotNull(arrayPool, "arrayPool");
			this.arrayPool = arrayPool;
		}

		public static implicit operator ReadOnlySequence<T>(Sequence<T> sequence)
		{
			SequenceSegment sequenceSegment = sequence.first;
			if (sequenceSegment != null)
			{
				SequenceSegment sequenceSegment2 = sequence.last;
				if (sequenceSegment2 != null)
				{
					return new ReadOnlySequence<T>(sequenceSegment, sequenceSegment.Start, sequenceSegment2, sequenceSegment2.End);
				}
			}
			return Empty;
		}

		public void AdvanceTo(SequencePosition position)
		{
			SequenceSegment sequenceSegment = (SequenceSegment)position.GetObject();
			if (sequenceSegment != null && (sequenceSegment != SequenceSegment.Empty || Length != 0L))
			{
				int integer = position.GetInteger();
				SequenceSegment next = first;
				while (next != sequenceSegment && next != null)
				{
					next = next.Next;
				}
				Requires.Argument(next != null, "position", "Position does not represent a valid position in this sequence.");
				Requires.Argument(integer >= next.Start, "position", "Position must not be earlier than current position.");
				for (next = first; next != sequenceSegment; next = RecycleAndGetNext(next))
				{
				}
				sequenceSegment.AdvanceTo(integer);
				first = ((sequenceSegment.Length == 0) ? RecycleAndGetNext(sequenceSegment) : sequenceSegment);
				if (first == null)
				{
					last = null;
				}
			}
		}

		public void Advance(int count)
		{
			SequenceSegment? sequenceSegment = last;
			Verify.Operation(sequenceSegment != null, "Cannot advance before acquiring memory.");
			sequenceSegment.Advance(count);
			ConsiderMinimumSizeIncrease();
		}

		public Memory<T> GetMemory(int sizeHint)
		{
			return GetSegment(sizeHint).RemainingMemory;
		}

		public Span<T> GetSpan(int sizeHint)
		{
			return GetSegment(sizeHint).RemainingSpan;
		}

		public void Append(ReadOnlyMemory<T> memory)
		{
			if (memory.Length > 0)
			{
				SequenceSegment sequenceSegment = ((segmentPool.Count > 0) ? segmentPool.Pop() : new SequenceSegment());
				sequenceSegment.AssignForeign(memory);
				Append(sequenceSegment);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public void Dispose()
		{
			Reset();
		}

		public void Reset()
		{
			for (SequenceSegment sequenceSegment = first; sequenceSegment != null; sequenceSegment = RecycleAndGetNext(sequenceSegment))
			{
			}
			first = (last = null);
		}

		private SequenceSegment GetSegment(int sizeHint)
		{
			Requires.Range(sizeHint >= 0, "sizeHint");
			int? num = null;
			if (sizeHint == 0)
			{
				if (last == null || last.WritableBytes == 0)
				{
					num = -1;
				}
			}
			else if (last == null || last.WritableBytes < sizeHint)
			{
				num = Math.Max(MinimumSpanLength, sizeHint);
			}
			if (num.HasValue)
			{
				SequenceSegment sequenceSegment = ((segmentPool.Count > 0) ? segmentPool.Pop() : new SequenceSegment());
				if (arrayPool != null)
				{
					sequenceSegment.Assign(arrayPool.Rent((num.Value == -1) ? DefaultLengthFromArrayPool : num.Value));
				}
				else
				{
					sequenceSegment.Assign(memoryPool.Rent(num.Value));
				}
				Append(sequenceSegment);
			}
			return last;
		}

		private void Append(SequenceSegment segment)
		{
			if (last == null)
			{
				first = (last = segment);
				return;
			}
			if (last.Length > 0)
			{
				last.SetNext(segment);
			}
			else
			{
				SequenceSegment next = first;
				if (first != last)
				{
					while (next.Next != last)
					{
						next = next.Next;
					}
				}
				else
				{
					first = segment;
				}
				next.SetNext(segment);
				RecycleAndGetNext(last);
			}
			last = segment;
		}

		private SequenceSegment? RecycleAndGetNext(SequenceSegment segment)
		{
			SequenceSegment? next = segment.Next;
			segment.ResetMemory(arrayPool);
			segmentPool.Push(segment);
			return next;
		}

		private void ConsiderMinimumSizeIncrease()
		{
			checked
			{
				if (AutoIncreaseMinimumSpanLength && MinimumSpanLength < 32768)
				{
					int num = Math.Min(32768, (int)Math.Min(2147483647L, unchecked(Length / 2)));
					if (MinimumSpanLength < num)
					{
						MinimumSpanLength = num;
					}
				}
			}
		}

		static Sequence()
		{
			checked
			{
				DefaultLengthFromArrayPool = 1 + unchecked(4095 / Unsafe.SizeOf<T>());
				Empty = new ReadOnlySequence<T>(SequenceSegment.Empty, 0, SequenceSegment.Empty, 0);
			}
		}
	}
	internal static class Requires
	{
		[DebuggerStepThrough]
		public static void Range([DoesNotReturnIf(false)] bool condition, string parameterName, string? message = null)
		{
			if (!condition)
			{
				FailRange(parameterName, message);
			}
		}

		[DebuggerStepThrough]
		public static Exception FailRange(string parameterName, string? message = null)
		{
			if (string.IsNullOrEmpty(message))
			{
				throw new ArgumentOutOfRangeException(parameterName);
			}
			throw new ArgumentOutOfRangeException(parameterName, message);
		}

		[DebuggerStepThrough]
		public static T NotNull<T>([NotNull] T value, string parameterName) where T : class
		{
			if (value == null)
			{
				throw new ArgumentNullException(parameterName);
			}
			return value;
		}

		[DebuggerStepThrough]
		public static void Argument([DoesNotReturnIf(false)] bool condition, string parameterName, string message)
		{
			if (!condition)
			{
				throw new ArgumentException(message, parameterName);
			}
		}

		[DebuggerStepThrough]
		public static void Argument([DoesNotReturnIf(false)] bool condition, string parameterName, string message, object arg1)
		{
			if (!condition)
			{
				throw new ArgumentException(string.Format(message, arg1), parameterName);
			}
		}

		[DebuggerStepThrough]
		public static void Argument([DoesNotReturnIf(false)] bool condition, string parameterName, string message, object arg1, object arg2)
		{
			if (!condition)
			{
				throw new ArgumentException(string.Format(message, arg1, arg2), parameterName);
			}
		}

		[DebuggerStepThrough]
		public static void Argument([DoesNotReturnIf(false)] bool condition, string parameterName, string message, params object[] args)
		{
			if (!condition)
			{
				throw new ArgumentException(string.Format(message, args), parameterName);
			}
		}
	}
	internal static class Verify
	{
		[DebuggerStepThrough]
		internal static void Operation([DoesNotReturnIf(false)] bool condition, string message)
		{
			if (!condition)
			{
				throw new InvalidOperationException(message);
			}
		}
	}
}
namespace MessagePack
{
	public ref struct MessagePackReader
	{
		private SequenceReader<byte> reader;

		public CancellationToken CancellationToken { get; set; }

		public int Depth { get; set; }

		public ReadOnlySequence<byte> Sequence => reader.Sequence;

		public SequencePosition Position => reader.Position;

		public long Consumed => reader.Consumed;

		public bool End => reader.End;

		public bool IsNil => NextCode == 192;

		public MessagePackType NextMessagePackType => MessagePackCode.ToMessagePackType(NextCode);

		public byte NextCode
		{
			get
			{
				ThrowInsufficientBufferUnless(reader.TryPeek(out var value));
				return value;
			}
		}

		public byte ReadByte()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			checked
			{
				switch (value)
				{
				case 204:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
					return value3;
				}
				case 208:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
					return (byte)value2;
				}
				case 205:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
					return (byte)value4;
				}
				case 209:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
					return (byte)value9;
				}
				case 206:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
					return (byte)value8;
				}
				case 210:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
					return (byte)value7;
				}
				case 207:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
					return (byte)value6;
				}
				case 211:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
					return (byte)value5;
				}
				case 224:
				case 225:
				case 226:
				case 227:
				case 228:
				case 229:
				case 230:
				case 231:
				case 232:
				case 233:
				case 234:
				case 235:
				case 236:
				case 237:
				case 238:
				case 239:
				case 240:
				case 241:
				case 242:
				case 243:
				case 244:
				case 245:
				case 246:
				case 247:
				case 248:
				case 249:
				case 250:
				case 251:
				case 252:
				case 253:
				case 254:
				case byte.MaxValue:
					return (byte)unchecked((sbyte)value);
				default:
					if (value >= 0 && value <= 127)
					{
						return value;
					}
					throw ThrowInvalidCode(value);
				}
			}
		}

		public ushort ReadUInt16()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			checked
			{
				switch (value)
				{
				case 204:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
					return value3;
				}
				case 208:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
					return (ushort)value2;
				}
				case 205:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
					return value4;
				}
				case 209:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
					return (ushort)value9;
				}
				case 206:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
					return (ushort)value8;
				}
				case 210:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
					return (ushort)value7;
				}
				case 207:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
					return (ushort)value6;
				}
				case 211:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
					return (ushort)value5;
				}
				case 224:
				case 225:
				case 226:
				case 227:
				case 228:
				case 229:
				case 230:
				case 231:
				case 232:
				case 233:
				case 234:
				case 235:
				case 236:
				case 237:
				case 238:
				case 239:
				case 240:
				case 241:
				case 242:
				case 243:
				case 244:
				case 245:
				case 246:
				case 247:
				case 248:
				case 249:
				case 250:
				case 251:
				case 252:
				case 253:
				case 254:
				case byte.MaxValue:
					return (ushort)unchecked((sbyte)value);
				default:
					if (value >= 0 && value <= 127)
					{
						return value;
					}
					throw ThrowInvalidCode(value);
				}
			}
		}

		public uint ReadUInt32()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			checked
			{
				switch (value)
				{
				case 204:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
					return value3;
				}
				case 208:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
					return (uint)value2;
				}
				case 205:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
					return value4;
				}
				case 209:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
					return (uint)value9;
				}
				case 206:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
					return value8;
				}
				case 210:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
					return (uint)value7;
				}
				case 207:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
					return (uint)value6;
				}
				case 211:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
					return (uint)value5;
				}
				case 224:
				case 225:
				case 226:
				case 227:
				case 228:
				case 229:
				case 230:
				case 231:
				case 232:
				case 233:
				case 234:
				case 235:
				case 236:
				case 237:
				case 238:
				case 239:
				case 240:
				case 241:
				case 242:
				case 243:
				case 244:
				case 245:
				case 246:
				case 247:
				case 248:
				case 249:
				case 250:
				case 251:
				case 252:
				case 253:
				case 254:
				case byte.MaxValue:
					return (uint)unchecked((sbyte)value);
				default:
					if (value >= 0 && value <= 127)
					{
						return value;
					}
					throw ThrowInvalidCode(value);
				}
			}
		}

		public ulong ReadUInt64()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			checked
			{
				switch (value)
				{
				case 204:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
					return value3;
				}
				case 208:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
					return (ulong)value2;
				}
				case 205:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
					return value4;
				}
				case 209:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
					return (ulong)value9;
				}
				case 206:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
					return value8;
				}
				case 210:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
					return (ulong)value7;
				}
				case 207:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
					return value6;
				}
				case 211:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
					return (ulong)value5;
				}
				case 224:
				case 225:
				case 226:
				case 227:
				case 228:
				case 229:
				case 230:
				case 231:
				case 232:
				case 233:
				case 234:
				case 235:
				case 236:
				case 237:
				case 238:
				case 239:
				case 240:
				case 241:
				case 242:
				case 243:
				case 244:
				case 245:
				case 246:
				case 247:
				case 248:
				case 249:
				case 250:
				case 251:
				case 252:
				case 253:
				case 254:
				case byte.MaxValue:
					return (ulong)unchecked((sbyte)value);
				default:
					if (value >= 0 && value <= 127)
					{
						return value;
					}
					throw ThrowInvalidCode(value);
				}
			}
		}

		public sbyte ReadSByte()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			checked
			{
				switch (value)
				{
				case 204:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
					return (sbyte)value3;
				}
				case 208:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
					return value2;
				}
				case 205:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
					return (sbyte)value4;
				}
				case 209:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
					return (sbyte)value9;
				}
				case 206:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
					return (sbyte)value8;
				}
				case 210:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
					return (sbyte)value7;
				}
				case 207:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
					return (sbyte)value6;
				}
				case 211:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
					return (sbyte)value5;
				}
				case 224:
				case 225:
				case 226:
				case 227:
				case 228:
				case 229:
				case 230:
				case 231:
				case 232:
				case 233:
				case 234:
				case 235:
				case 236:
				case 237:
				case 238:
				case 239:
				case 240:
				case 241:
				case 242:
				case 243:
				case 244:
				case 245:
				case 246:
				case 247:
				case 248:
				case 249:
				case 250:
				case 251:
				case 252:
				case 253:
				case 254:
				case byte.MaxValue:
					return unchecked((sbyte)value);
				default:
					if (value >= 0 && value <= 127)
					{
						return (sbyte)value;
					}
					throw ThrowInvalidCode(value);
				}
			}
		}

		public short ReadInt16()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			checked
			{
				switch (value)
				{
				case 204:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
					return value3;
				}
				case 208:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
					return value2;
				}
				case 205:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
					return (short)value4;
				}
				case 209:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
					return value9;
				}
				case 206:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
					return (short)value8;
				}
				case 210:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
					return (short)value7;
				}
				case 207:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
					return (short)value6;
				}
				case 211:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
					return (short)value5;
				}
				case 224:
				case 225:
				case 226:
				case 227:
				case 228:
				case 229:
				case 230:
				case 231:
				case 232:
				case 233:
				case 234:
				case 235:
				case 236:
				case 237:
				case 238:
				case 239:
				case 240:
				case 241:
				case 242:
				case 243:
				case 244:
				case 245:
				case 246:
				case 247:
				case 248:
				case 249:
				case 250:
				case 251:
				case 252:
				case 253:
				case 254:
				case byte.MaxValue:
					return unchecked((sbyte)value);
				default:
					if (value >= 0 && value <= 127)
					{
						return value;
					}
					throw ThrowInvalidCode(value);
				}
			}
		}

		public int ReadInt32()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			checked
			{
				switch (value)
				{
				case 204:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
					return value3;
				}
				case 208:
				{
					ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
					return value2;
				}
				case 205:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
					return value4;
				}
				case 209:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
					return value9;
				}
				case 206:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
					return (int)value8;
				}
				case 210:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
					return value7;
				}
				case 207:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
					return (int)value6;
				}
				case 211:
				{
					ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
					return (int)value5;
				}
				case 224:
				case 225:
				case 226:
				case 227:
				case 228:
				case 229:
				case 230:
				case 231:
				case 232:
				case 233:
				case 234:
				case 235:
				case 236:
				case 237:
				case 238:
				case 239:
				case 240:
				case 241:
				case 242:
				case 243:
				case 244:
				case 245:
				case 246:
				case 247:
				case 248:
				case 249:
				case 250:
				case 251:
				case 252:
				case 253:
				case 254:
				case byte.MaxValue:
					return unchecked((sbyte)value);
				default:
					if (value >= 0 && value <= 127)
					{
						return value;
					}
					throw ThrowInvalidCode(value);
				}
			}
		}

		public long ReadInt64()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			switch (value)
			{
			case 204:
			{
				ThrowInsufficientBufferUnless(reader.TryRead(out var value3));
				return value3;
			}
			case 208:
			{
				ThrowInsufficientBufferUnless(reader.TryRead(out var value2));
				return value2;
			}
			case 205:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value4));
				return value4;
			}
			case 209:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value9));
				return value9;
			}
			case 206:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value8));
				return value8;
			}
			case 210:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value7));
				return value7;
			}
			case 207:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value6));
				return checked((long)value6);
			}
			case 211:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value5));
				return value5;
			}
			case 224:
			case 225:
			case 226:
			case 227:
			case 228:
			case 229:
			case 230:
			case 231:
			case 232:
			case 233:
			case 234:
			case 235:
			case 236:
			case 237:
			case 238:
			case 239:
			case 240:
			case 241:
			case 242:
			case 243:
			case 244:
			case 245:
			case 246:
			case 247:
			case 248:
			case 249:
			case 250:
			case 251:
			case 252:
			case 253:
			case 254:
			case byte.MaxValue:
				return (sbyte)value;
			default:
				if (value >= 0 && value <= 127)
				{
					return value;
				}
				throw ThrowInvalidCode(value);
			}
		}

		public MessagePackReader(ReadOnlyMemory<byte> memory)
		{
			this = default(MessagePackReader);
			reader = new SequenceReader<byte>(memory);
			Depth = 0;
		}

		public MessagePackReader(in ReadOnlySequence<byte> readOnlySequence)
		{
			this = default(MessagePackReader);
			reader = new SequenceReader<byte>(in readOnlySequence);
			Depth = 0;
		}

		public MessagePackReader Clone(in ReadOnlySequence<byte> readOnlySequence)
		{
			MessagePackReader result = new MessagePackReader(in readOnlySequence);
			result.CancellationToken = CancellationToken;
			result.Depth = Depth;
			return result;
		}

		public MessagePackReader CreatePeekReader()
		{
			return this;
		}

		public void Skip()
		{
			ThrowInsufficientBufferUnless(TrySkip());
		}

		internal bool TrySkip()
		{
			if (reader.Remaining == 0L)
			{
				return false;
			}
			byte nextCode = NextCode;
			int length;
			switch (nextCode)
			{
			case 192:
			case 194:
			case 195:
				return reader.TryAdvance(1L);
			case 204:
			case 208:
				return reader.TryAdvance(2L);
			case 205:
			case 209:
				return reader.TryAdvance(3L);
			case 202:
			case 206:
			case 210:
				return reader.TryAdvance(5L);
			case 203:
			case 207:
			case 211:
				return reader.TryAdvance(9L);
			case 222:
			case 223:
				return TrySkipNextMap();
			case 220:
			case 221:
				return TrySkipNextArray();
			case 217:
			case 218:
			case 219:
				if (TryGetStringLengthInBytes(out length))
				{
					return reader.TryAdvance(length);
				}
				return false;
			case 196:
			case 197:
			case 198:
				if (TryGetBytesLength(out length))
				{
					return reader.TryAdvance(length);
				}
				return false;
			case 199:
			case 200:
			case 201:
			case 212:
			case 213:
			case 214:
			case 215:
			case 216:
			{
				if (TryReadExtensionFormatHeader(out var extensionHeader))
				{
					return reader.TryAdvance(extensionHeader.Length);
				}
				return false;
			}
			default:
				if (nextCode < 0 || nextCode > 127)
				{
					break;
				}
				goto case 224;
			case 224:
			case 225:
			case 226:
			case 227:
			case 228:
			case 229:
			case 230:
			case 231:
			case 232:
			case 233:
			case 234:
			case 235:
			case 236:
			case 237:
			case 238:
			case 239:
			case 240:
			case 241:
			case 242:
			case 243:
			case 244:
			case 245:
			case 246:
			case 247:
			case 248:
			case 249:
			case 250:
			case 251:
			case 252:
			case 253:
			case 254:
			case byte.MaxValue:
				return reader.TryAdvance(1L);
			}
			if (nextCode >= 128 && nextCode <= 143)
			{
				return TrySkipNextMap();
			}
			if (nextCode >= 144 && nextCode <= 159)
			{
				return TrySkipNextArray();
			}
			if (nextCode >= 160 && nextCode <= 191)
			{
				if (TryGetStringLengthInBytes(out length))
				{
					return reader.TryAdvance(length);
				}
				return false;
			}
			throw ThrowInvalidCode(nextCode);
		}

		public Nil ReadNil()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			if (value != 192)
			{
				throw ThrowInvalidCode(value);
			}
			return Nil.Default;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryReadNil()
		{
			if (NextCode == 192)
			{
				reader.Advance(1L);
				return true;
			}
			return false;
		}

		public ReadOnlySequence<byte> ReadRaw(long length)
		{
			try
			{
				ReadOnlySequence<byte> result = reader.Sequence.Slice(reader.Position, length);
				reader.Advance(length);
				return result;
			}
			catch (ArgumentOutOfRangeException innerException)
			{
				throw ThrowNotEnoughBytesException(innerException);
			}
		}

		public ReadOnlySequence<byte> ReadRaw()
		{
			SequencePosition position = Position;
			Skip();
			return Sequence.Slice(position, Position);
		}

		public int ReadArrayHeader()
		{
			ThrowInsufficientBufferUnless(TryReadArrayHeader(out var count));
			ThrowInsufficientBufferUnless(reader.Remaining >= count);
			return count;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryReadArrayHeader(out int count)
		{
			count = -1;
			if (!reader.TryRead(out var value))
			{
				return false;
			}
			switch (value)
			{
			case 220:
			{
				if (!reader.TryReadBigEndian(out short value3))
				{
					return false;
				}
				count = (ushort)value3;
				break;
			}
			case 221:
			{
				if (!reader.TryReadBigEndian(out int value2))
				{
					return false;
				}
				count = value2;
				break;
			}
			case 144:
			case 145:
			case 146:
			case 147:
			case 148:
			case 149:
			case 150:
			case 151:
			case 152:
			case 153:
			case 154:
			case 155:
			case 156:
			case 157:
			case 158:
			case 159:
				count = value & 0xF;
				break;
			default:
				throw ThrowInvalidCode(value);
			}
			return true;
		}

		public int ReadMapHeader()
		{
			ThrowInsufficientBufferUnless(TryReadMapHeader(out var count));
			ThrowInsufficientBufferUnless(reader.Remaining >= checked(count * 2));
			return count;
		}

		public bool TryReadMapHeader(out int count)
		{
			count = -1;
			if (!reader.TryRead(out var value))
			{
				return false;
			}
			switch (value)
			{
			case 222:
			{
				if (!reader.TryReadBigEndian(out short value3))
				{
					return false;
				}
				count = (ushort)value3;
				break;
			}
			case 223:
			{
				if (!reader.TryReadBigEndian(out int value2))
				{
					return false;
				}
				count = value2;
				break;
			}
			case 128:
			case 129:
			case 130:
			case 131:
			case 132:
			case 133:
			case 134:
			case 135:
			case 136:
			case 137:
			case 138:
			case 139:
			case 140:
			case 141:
			case 142:
			case 143:
				count = checked((byte)(value & 0xF));
				break;
			default:
				throw ThrowInvalidCode(value);
			}
			return true;
		}

		public bool ReadBoolean()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			return value switch
			{
				195 => true, 
				194 => false, 
				_ => throw ThrowInvalidCode(value), 
			};
		}

		public char ReadChar()
		{
			return (char)ReadUInt16();
		}

		public float ReadSingle()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			switch (value)
			{
			case 202:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out float value3));
				return value3;
			}
			case 203:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out double value2));
				return (float)value2;
			}
			case 208:
			{
				ThrowInsufficientBufferUnless(reader.TryRead(out var value4));
				return value4;
			}
			case 209:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out short value11));
				return value11;
			}
			case 210:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out int value10));
				return value10;
			}
			case 211:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out long value9));
				return value9;
			}
			case 204:
			{
				ThrowInsufficientBufferUnless(reader.TryRead(out var value8));
				return (int)value8;
			}
			case 205:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ushort value7));
				return (int)value7;
			}
			case 206:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out uint value6));
				return value6;
			}
			case 207:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out ulong value5));
				return value5;
			}
			case 224:
			case 225:
			case 226:
			case 227:
			case 228:
			case 229:
			case 230:
			case 231:
			case 232:
			case 233:
			case 234:
			case 235:
			case 236:
			case 237:
			case 238:
			case 239:
			case 240:
			case 241:
			case 242:
			case 243:
			case 244:
			case 245:
			case 246:
			case 247:
			case 248:
			case 249:
			case 250:
			case 251:
			case 252:
			case 253:
			case 254:
			case byte.MaxValue:
				return (sbyte)value;
			default:
				if (value >= 0 && value <= 127)
				{
					return (int)value;
				}
				throw ThrowInvalidCode(value);
			}
		}

		public double ReadDouble()
		{
			ThrowInsufficientBufferUnless(reader.TryRead(out var value));
			byte value4;
			short value7;
			int value6;
			long value5;
			switch (value)
			{
			case 203:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out double value3));
				return value3;
			}
			case 202:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out float value2));
				return value2;
			}
			case 208:
				ThrowInsufficientBufferUnless(reader.TryRead(out value4));
				return (sbyte)value4;
			case 209:
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value7));
				return value7;
			case 210:
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value6));
				return value6;
			case 211:
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value5));
				return value5;
			case 204:
				ThrowInsufficientBufferUnless(reader.TryRead(out value4));
				return (int)value4;
			case 205:
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value7));
				return (int)(ushort)value7;
			case 206:
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value6));
				return (uint)value6;
			case 207:
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value5));
				return (ulong)value5;
			case 224:
			case 225:
			case 226:
			case 227:
			case 228:
			case 229:
			case 230:
			case 231:
			case 232:
			case 233:
			case 234:
			case 235:
			case 236:
			case 237:
			case 238:
			case 239:
			case 240:
			case 241:
			case 242:
			case 243:
			case 244:
			case 245:
			case 246:
			case 247:
			case 248:
			case 249:
			case 250:
			case 251:
			case 252:
			case 253:
			case 254:
			case byte.MaxValue:
				return (sbyte)value;
			default:
				if (value >= 0 && value <= 127)
				{
					return (int)value;
				}
				throw ThrowInvalidCode(value);
			}
		}

		public DateTime ReadDateTime()
		{
			return ReadDateTime(ReadExtensionFormatHeader());
		}

		public DateTime ReadDateTime(ExtensionHeader header)
		{
			if (header.TypeCode != -1)
			{
				throw new MessagePackSerializationException($"Extension TypeCode is invalid. typeCode: {header.TypeCode}");
			}
			int value;
			long value2;
			switch (header.Length)
			{
			case 4u:
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value));
				return DateTimeConstants.UnixEpoch.AddSeconds((uint)value);
			case 8u:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value2));
				long num2 = value2;
				long num;
				checked
				{
					num = (long)(unchecked((ulong)num2) >> 34);
				}
				ulong num3 = (ulong)num2 & 0x3FFFFFFFFuL;
				return DateTimeConstants.UnixEpoch.AddSeconds(num3).AddTicks(num / 100);
			}
			case 12u:
			{
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value));
				long num = (uint)value;
				ThrowInsufficientBufferUnless(reader.TryReadBigEndian(out value2));
				return DateTimeConstants.UnixEpoch.AddSeconds(value2).AddTicks(num / 100);
			}
			default:
				throw new MessagePackSerializationException($"Length of extension was {header.Length}. Either 4 or 8 were expected.");
			}
		}

		public ReadOnlySequence<byte>? ReadBytes()
		{
			if (TryReadNil())
			{
				return null;
			}
			int bytesLength = GetBytesLength();
			ThrowInsufficientBufferUnless(reader.Remaining >= bytesLength);
			ReadOnlySequence<byte> value = reader.Sequence.Slice(reader.Position, bytesLength);
			reader.Advance(bytesLength);
			return value;
		}

		public ReadOnlySequence<byte>? ReadStringSequence()
		{
			if (TryReadNil())
			{
				return null;
			}
			int stringLengthInBytes = GetStringLengthInBytes();
			ThrowInsufficientBufferUnless(reader.Remaining >= stringLengthInBytes);
			ReadOnlySequence<byte> value = reader.Sequence.Slice(reader.Position, stringLengthInBytes);
			reader.Advance(stringLengthInBytes);
			return value;
		}

		public bool TryReadStringSpan(out ReadOnlySpan<byte> span)
		{
			if (IsNil)
			{
				span = default(ReadOnlySpan<byte>);
				return false;
			}
			long consumed = reader.Consumed;
			int stringLengthInBytes = GetStringLengthInBytes();
			ThrowInsufficientBufferUnless(reader.Remaining >= stringLengthInBytes);
			checked
			{
				int num = reader.CurrentSpanIndex + stringLengthInBytes;
				ReadOnlySpan<byte> currentSpan = reader.CurrentSpan;
				if (num <= currentSpan.Length)
				{
					currentSpan = reader.CurrentSpan;
					span = currentSpan.Slice(reader.CurrentSpanIndex, stringLengthInBytes);
					reader.Advance(stringLengthInBytes);
					return true;
				}
				reader.Rewind(reader.Consumed - consumed);
				span = default(ReadOnlySpan<byte>);
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public string? ReadString()
		{
			if (TryReadNil())
			{
				return null;
			}
			int stringLengthInBytes = GetStringLengthInBytes();
			ReadOnlySpan<byte> unreadSpan = reader.UnreadSpan;
			if (unreadSpan.Length >= stringLengthInBytes)
			{
				string @string = StringEncoding.UTF8.GetString(unreadSpan.Slice(0, stringLengthInBytes));
				reader.Advance(stringLengthInBytes);
				return @string;
			}
			return ReadStringSlow(stringLengthInBytes);
		}

		public ExtensionHeader ReadExtensionFormatHeader()
		{
			ThrowInsufficientBufferUnless(TryReadExtensionFormatHeader(out var extensionHeader));
			ThrowInsufficientBufferUnless(reader.Remaining >= extensionHeader.Length);
			return extensionHeader;
		}

		public bool TryReadExtensionFormatHeader(out ExtensionHeader extensionHeader)
		{
			extensionHeader = default(ExtensionHeader);
			if (!reader.TryRead(out var value))
			{
				return false;
			}
			uint length;
			switch (value)
			{
			case 212:
				length = 1u;
				break;
			case 213:
				length = 2u;
				break;
			case 214:
				length = 4u;
				break;
			case 215:
				length = 8u;
				break;
			case 216:
				length = 16u;
				break;
			case 199:
			{
				if (!reader.TryRead(out var value4))
				{
					return false;
				}
				length = value4;
				break;
			}
			case 200:
			{
				if (!reader.TryReadBigEndian(out short value3))
				{
					return false;
				}
				length = (ushort)value3;
				break;
			}
			case 201:
			{
				if (!reader.TryReadBigEndian(out int value2))
				{
					return false;
				}
				length = (uint)value2;
				break;
			}
			default:
				throw ThrowInvalidCode(value);
			}
			if (!reader.TryRead(out var value5))
			{
				return false;
			}
			extensionHeader = new ExtensionHeader((sbyte)value5, length);
			return true;
		}

		public ExtensionResult ReadExtensionFormat()
		{
			ExtensionHeader extensionHeader = ReadExtensionFormatHeader();
			try
			{
				ReadOnlySequence<byte> data = reader.Sequence.Slice(reader.Position, extensionHeader.Length);
				reader.Advance(extensionHeader.Length);
				return new ExtensionResult(extensionHeader.TypeCode, data);
			}
			catch (ArgumentOutOfRangeException innerException)
			{
				throw ThrowNotEnoughBytesException(innerException);
			}
		}

		private static EndOfStreamException ThrowNotEnoughBytesException()
		{
			throw new EndOfStreamException();
		}

		private static EndOfStreamException ThrowNotEnoughBytesException(Exception innerException)
		{
			throw new EndOfStreamException(new EndOfStreamException().Message, innerException);
		}

		[DoesNotReturn]
		private static Exception ThrowInvalidCode(byte code)
		{
			throw new MessagePackSerializationException($"Unexpected msgpack code {code} ({MessagePackCode.ToFormatName(code)}) encountered.");
		}

		private static void ThrowInsufficientBufferUnless(bool condition)
		{
			if (!condition)
			{
				ThrowNotEnoughBytesException();
			}
		}

		private int GetBytesLength()
		{
			ThrowInsufficientBufferUnless(TryGetBytesLength(out var length));
			return length;
		}

		private bool TryGetBytesLength(out int length)
		{
			if (!reader.TryRead(out var value))
			{
				length = 0;
				return false;
			}
			switch (value)
			{
			case 196:
			{
				if (reader.TryRead(out var value2))
				{
					length = value2;
					return true;
				}
				break;
			}
			case 197:
			case 218:
			{
				if (reader.TryReadBigEndian(out short value3))
				{
					length = (ushort)value3;
					return true;
				}
				break;
			}
			case 198:
			case 219:
				if (reader.TryReadBigEndian(out length))
				{
					return true;
				}
				break;
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 169:
			case 170:
			case 171:
			case 172:
			case 173:
			case 174:
			case 175:
			case 176:
			case 177:
			case 178:
			case 179:
			case 180:
			case 181:
			case 182:
			case 183:
			case 184:
			case 185:
			case 186:
			case 187:
			case 188:
			case 189:
			case 190:
			case 191:
				length = value & 0x1F;
				return true;
			default:
				throw ThrowInvalidCode(value);
			}
			length = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool TryGetStringLengthInBytes(out int length)
		{
			if (!reader.TryRead(out var value))
			{
				length = 0;
				return false;
			}
			if (value >= 160 && value <= 191)
			{
				length = value & 0x1F;
				return true;
			}
			return TryGetStringLengthInBytesSlow(value, out length);
		}

		private int GetStringLengthInBytes()
		{
			ThrowInsufficientBufferUnless(TryGetStringLengthInBytes(out var length));
			return length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool TryGetStringLengthInBytesSlow(byte code, out int length)
		{
			switch (code)
			{
			case 217:
			{
				if (reader.TryRead(out var value2))
				{
					length = value2;
					return true;
				}
				break;
			}
			case 218:
			{
				if (reader.TryReadBigEndian(out short value3))
				{
					length = (ushort)value3;
					return true;
				}
				break;
			}
			case 219:
			{
				if (reader.TryReadBigEndian(out int value))
				{
					length = value;
					return true;
				}
				break;
			}
			case 160:
			case 161:
			case 162:
			case 163:
			case 164:
			case 165:
			case 166:
			case 167:
			case 168:
			case 169:
			case 170:
			case 171:
			case 172:
			case 173:
			case 174:
			case 175:
			case 176:
			case 177:
			case 178:
			case 179:
			case 180:
			case 181:
			case 182:
			case 183:
			case 184:
			case 185:
			case 186:
			case 187:
			case 188:
			case 189:
			case 190:
			case 191:
				length = code & 0x1F;
				return true;
			default:
				throw ThrowInvalidCode(code);
			}
			length = 0;
			return false;
		}

		private string ReadStringSlow(int byteLength)
		{
			ThrowInsufficientBufferUnless(reader.Remaining >= byteLength);
			int maxCharCount = StringEncoding.UTF8.GetMaxCharCount(byteLength);
			char[] array = ArrayPool<char>.Shared.Rent(maxCharCount);
			Decoder decoder = StringEncoding.UTF8.GetDecoder();
			int num = byteLength;
			int num2 = 0;
			checked
			{
				while (num > 0)
				{
					int num3 = Math.Min(num, reader.UnreadSpan.Length);
					num -= num3;
					bool flush = num == 0;
					num2 += decoder.GetChars(reader.UnreadSpan.Slice(0, num3), array.AsSpan(num2), flush);
					reader.Advance(num3);
				}
				string result = new string(array, 0, num2);
				ArrayPool<char>.Shared.Return(array);
				return result;
			}
		}

		private bool TrySkipNextArray()
		{
			if (TryReadArrayHeader(out var count))
			{
				return TrySkip(count);
			}
			return false;
		}

		private bool TrySkipNextMap()
		{
			if (TryReadMapHeader(out var count))
			{
				return TrySkip(checked(count * 2));
			}
			return false;
		}

		private bool TrySkip(int count)
		{
			for (int i = 0; i < count; i = checked(i + 1))
			{
				if (!TrySkip())
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class MessagePackSerializer
	{
		public static class Typeless
		{
			public static MessagePackSerializerOptions DefaultOptions { get; set; } = TypelessContractlessStandardResolver.Options;


			public static void Serialize(ref MessagePackWriter writer, object? obj, MessagePackSerializerOptions? options = null)
			{
				MessagePackSerializer.Serialize(ref writer, obj, options ?? DefaultOptions);
			}

			public static void Serialize(IBufferWriter<byte> writer, object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				MessagePackSerializer.Serialize(writer, obj, options ?? DefaultOptions, cancellationToken);
			}

			public static byte[] Serialize(object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				return MessagePackSerializer.Serialize(obj, options ?? DefaultOptions, cancellationToken);
			}

			public static void Serialize(Stream stream, object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				MessagePackSerializer.Serialize(stream, obj, options ?? DefaultOptions, cancellationToken);
			}

			public static Task SerializeAsync(Stream stream, object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				return MessagePackSerializer.SerializeAsync(stream, obj, options ?? DefaultOptions, cancellationToken);
			}

			public static object? Deserialize(ref MessagePackReader reader, MessagePackSerializerOptions? options = null)
			{
				return Deserialize<object>(ref reader, options ?? DefaultOptions);
			}

			public static object? Deserialize(in ReadOnlySequence<byte> byteSequence, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				return Deserialize<object>(in byteSequence, options ?? DefaultOptions, cancellationToken);
			}

			public static object? Deserialize(Stream stream, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				return Deserialize<object>(stream, options ?? DefaultOptions, cancellationToken);
			}

			public static object? Deserialize(Memory<byte> bytes, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				return Deserialize<object>(bytes, options ?? DefaultOptions, cancellationToken);
			}

			public static ValueTask<object?> DeserializeAsync(Stream stream, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
			{
				return DeserializeAsync<object>(stream, options ?? DefaultOptions, cancellationToken);
			}
		}

		private delegate int LZ4Transform(ReadOnlySpan<byte> input, Span<byte> output);

		private static class PrimitiveChecker<T>
		{
			public static readonly bool IsMessagePackFixedSizePrimitive;

			static PrimitiveChecker()
			{
				IsMessagePackFixedSizePrimitive = IsMessagePackFixedSizePrimitiveTypeHelper(typeof(T));
			}
		}

		private class CompiledMethods
		{
			internal delegate void MessagePackWriterSerialize(ref MessagePackWriter writer, object? value, MessagePackSerializerOptions? options);

			internal delegate object? MessagePackReaderDeserialize(ref MessagePackReader reader, MessagePackSerializerOptions? options);

			private const bool PreferInterpretation = false;

			internal readonly Func<object?, MessagePackSerializerOptions?, CancellationToken, byte[]> Serialize_T_Options;

			internal readonly Action<Stream, object?, MessagePackSerializerOptions?, CancellationToken> Serialize_Stream_T_Options_CancellationToken;

			internal readonly Func<Stream, object?, MessagePackSerializerOptions?, CancellationToken, Task> SerializeAsync_Stream_T_Options_CancellationToken;

			internal readonly MessagePackWriterSerialize Serialize_MessagePackWriter_T_Options;

			internal readonly Action<IBufferWriter<byte>, object?, MessagePackSerializerOptions?, CancellationToken> Serialize_IBufferWriter_T_Options_CancellationToken;

			internal readonly MessagePackReaderDeserialize Deserialize_MessagePackReader_Options;

			internal readonly Func<Stream, MessagePackSerializerOptions?, CancellationToken, object?> Deserialize_Stream_Options_CancellationToken;

			internal readonly Func<Stream, MessagePackSerializerOptions?, CancellationToken, ValueTask<object?>> DeserializeAsync_Stream_Options_CancellationToken;

			internal readonly Func<ReadOnlyMemory<byte>, MessagePackSerializerOptions?, CancellationToken, object?> Deserialize_ReadOnlyMemory_Options;

			internal readonly Func<ReadOnlySequence<byte>, MessagePackSerializerOptions?, CancellationToken, object?> Deserialize_ReadOnlySequence_Options_CancellationToken;

			internal CompiledMethods(Type type)
			{
				TypeInfo typeInfo = type.GetTypeInfo();
				MethodInfo method = GetMethod("Serialize", type, new Type[3]
				{
					null,
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression = Expression.Parameter(typeof(object), "obj");
				ParameterExpression parameterExpression2 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression3 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Serialize_T_Options = Expression.Lambda<Func<object, MessagePackSerializerOptions, CancellationToken, byte[]>>(Expression.Call(null, method, typeInfo.IsValueType ? Expression.Unbox(parameterExpression, type) : Expression.Convert(parameterExpression, type), parameterExpression2, parameterExpression3), new ParameterExpression[3] { parameterExpression, parameterExpression2, parameterExpression3 }).Compile(preferInterpretation: false);
				MethodInfo method2 = GetMethod("Serialize", type, new Type[4]
				{
					typeof(Stream),
					null,
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression4 = Expression.Parameter(typeof(Stream), "stream");
				ParameterExpression parameterExpression5 = Expression.Parameter(typeof(object), "obj");
				ParameterExpression parameterExpression6 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression7 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Action<Stream, object, MessagePackSerializerOptions, CancellationToken> serialize_Stream_T_Options_CancellationToken = Expression.Lambda<Action<Stream, object, MessagePackSerializerOptions, CancellationToken>>(Expression.Call(null, method2, parameterExpression4, typeInfo.IsValueType ? Expression.Unbox(parameterExpression5, type) : Expression.Convert(parameterExpression5, type), parameterExpression6, parameterExpression7), new ParameterExpression[4] { parameterExpression4, parameterExpression5, parameterExpression6, parameterExpression7 }).Compile(preferInterpretation: false);
				Serialize_Stream_T_Options_CancellationToken = serialize_Stream_T_Options_CancellationToken;
				MethodInfo method3 = GetMethod("SerializeAsync", type, new Type[4]
				{
					typeof(Stream),
					null,
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression8 = Expression.Parameter(typeof(Stream), "stream");
				ParameterExpression parameterExpression9 = Expression.Parameter(typeof(object), "obj");
				ParameterExpression parameterExpression10 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression11 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Func<Stream, object, MessagePackSerializerOptions, CancellationToken, Task> serializeAsync_Stream_T_Options_CancellationToken = Expression.Lambda<Func<Stream, object, MessagePackSerializerOptions, CancellationToken, Task>>(Expression.Call(null, method3, parameterExpression8, typeInfo.IsValueType ? Expression.Unbox(parameterExpression9, type) : Expression.Convert(parameterExpression9, type), parameterExpression10, parameterExpression11), new ParameterExpression[4] { parameterExpression8, parameterExpression9, parameterExpression10, parameterExpression11 }).Compile(preferInterpretation: false);
				SerializeAsync_Stream_T_Options_CancellationToken = serializeAsync_Stream_T_Options_CancellationToken;
				MethodInfo method4 = GetMethod("Serialize", type, new Type[4]
				{
					typeof(IBufferWriter<byte>),
					null,
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression12 = Expression.Parameter(typeof(IBufferWriter<byte>), "writer");
				ParameterExpression parameterExpression13 = Expression.Parameter(typeof(object), "obj");
				ParameterExpression parameterExpression14 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression15 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Action<IBufferWriter<byte>, object, MessagePackSerializerOptions, CancellationToken> serialize_IBufferWriter_T_Options_CancellationToken = Expression.Lambda<Action<IBufferWriter<byte>, object, MessagePackSerializerOptions, CancellationToken>>(Expression.Call(null, method4, parameterExpression12, typeInfo.IsValueType ? Expression.Unbox(parameterExpression13, type) : Expression.Convert(parameterExpression13, type), parameterExpression14, parameterExpression15), new ParameterExpression[4] { parameterExpression12, parameterExpression13, parameterExpression14, parameterExpression15 }).Compile(preferInterpretation: false);
				Serialize_IBufferWriter_T_Options_CancellationToken = serialize_IBufferWriter_T_Options_CancellationToken;
				MethodInfo method5 = GetMethod("SerializeSemiGeneric", type, new Type[3]
				{
					typeof(MessagePackWriter).MakeByRefType(),
					typeof(object),
					typeof(MessagePackSerializerOptions)
				});
				Serialize_MessagePackWriter_T_Options = (MessagePackWriterSerialize)method5.CreateDelegate(typeof(MessagePackWriterSerialize));
				MethodInfo method6 = GetMethod("DeserializeSemiGeneric", type, new Type[2]
				{
					typeof(MessagePackReader).MakeByRefType(),
					typeof(MessagePackSerializerOptions)
				});
				Deserialize_MessagePackReader_Options = (MessagePackReaderDeserialize)method6.CreateDelegate(typeof(MessagePackReaderDeserialize));
				MethodInfo method7 = GetMethod("Deserialize", type, new Type[3]
				{
					typeof(Stream),
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression16 = Expression.Parameter(typeof(Stream), "stream");
				ParameterExpression parameterExpression17 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression18 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Func<Stream, MessagePackSerializerOptions, CancellationToken, object> deserialize_Stream_Options_CancellationToken = Expression.Lambda<Func<Stream, MessagePackSerializerOptions, CancellationToken, object>>(Expression.Convert(Expression.Call(null, method7, parameterExpression16, parameterExpression17, parameterExpression18), typeof(object)), new ParameterExpression[3] { parameterExpression16, parameterExpression17, parameterExpression18 }).Compile(preferInterpretation: false);
				Deserialize_Stream_Options_CancellationToken = deserialize_Stream_Options_CancellationToken;
				MethodInfo method8 = GetMethod("DeserializeObjectAsync", type, new Type[3]
				{
					typeof(Stream),
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression19 = Expression.Parameter(typeof(Stream), "stream");
				ParameterExpression parameterExpression20 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression21 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Func<Stream, MessagePackSerializerOptions, CancellationToken, ValueTask<object>> deserializeAsync_Stream_Options_CancellationToken = Expression.Lambda<Func<Stream, MessagePackSerializerOptions, CancellationToken, ValueTask<object>>>(Expression.Convert(Expression.Call(null, method8, parameterExpression19, parameterExpression20, parameterExpression21), typeof(ValueTask<object>)), new ParameterExpression[3] { parameterExpression19, parameterExpression20, parameterExpression21 }).Compile(preferInterpretation: false);
				DeserializeAsync_Stream_Options_CancellationToken = deserializeAsync_Stream_Options_CancellationToken;
				MethodInfo method9 = GetMethod("Deserialize", type, new Type[3]
				{
					typeof(ReadOnlyMemory<byte>),
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression22 = Expression.Parameter(typeof(ReadOnlyMemory<byte>), "bytes");
				ParameterExpression parameterExpression23 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression24 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Func<ReadOnlyMemory<byte>, MessagePackSerializerOptions, CancellationToken, object> deserialize_ReadOnlyMemory_Options = Expression.Lambda<Func<ReadOnlyMemory<byte>, MessagePackSerializerOptions, CancellationToken, object>>(Expression.Convert(Expression.Call(null, method9, parameterExpression22, parameterExpression23, parameterExpression24), typeof(object)), new ParameterExpression[3] { parameterExpression22, parameterExpression23, parameterExpression24 }).Compile(preferInterpretation: false);
				Deserialize_ReadOnlyMemory_Options = deserialize_ReadOnlyMemory_Options;
				MethodInfo method10 = GetMethod("Deserialize", type, new Type[3]
				{
					typeof(ReadOnlySequence<byte>).MakeByRefType(),
					typeof(MessagePackSerializerOptions),
					typeof(CancellationToken)
				});
				ParameterExpression parameterExpression25 = Expression.Parameter(typeof(ReadOnlySequence<byte>), "bytes");
				ParameterExpression parameterExpression26 = Expression.Parameter(typeof(MessagePackSerializerOptions), "options");
				ParameterExpression parameterExpression27 = Expression.Parameter(typeof(CancellationToken), "cancellationToken");
				Func<ReadOnlySequence<byte>, MessagePackSerializerOptions, CancellationToken, object> deserialize_ReadOnlySequence_Options_CancellationToken = Expression.Lambda<Func<ReadOnlySequence<byte>, MessagePackSerializerOptions, CancellationToken, object>>(Expression.Convert(Expression.Call(null, method10, parameterExpression25, parameterExpression26, parameterExpression27), typeof(object)), new ParameterExpression[3] { parameterExpression25, parameterExpression26, parameterExpression27 }).Compile(preferInterpretation: false);
				Deserialize_ReadOnlySequence_Options_CancellationToken = deserialize_ReadOnlySequence_Options_CancellationToken;
			}

			private static void ThrowRefStructNotSupported()
			{
				throw new NotSupportedException("MessagePackWriter/Reader overload is not supported in MessagePackSerializer.NonGenerics.");
			}

			private static MethodInfo GetMethod(string methodName, Type type, Type?[] parameters)
			{
				string methodName2 = methodName;
				Type?[] parameters2 = parameters;
				return typeof(MessagePackSerializer).GetRuntimeMethods().Single(delegate(MethodInfo x)
				{
					if (methodName2 != x.Name)
					{
						return false;
					}
					ParameterInfo[] parameters3 = x.GetParameters();
					if (parameters3.Length != parameters2.Length)
					{
						return false;
					}
					for (int i = 0; i < parameters3.Length; i = checked(i + 1))
					{
						if ((!(parameters2[i] == null) || !parameters3[i].ParameterType.IsGenericParameter) && parameters3[i].ParameterType != parameters2[i])
						{
							return false;
						}
					}
					return true;
				}).MakeGenericMethod(type);
			}
		}

		private static MessagePackSerializerOptions? defaultOptions;

		[ThreadStatic]
		private static byte[]? scratchArray;

		private static readonly LZ4Transform LZ4CodecEncode;

		private static readonly LZ4Transform LZ4CodecDecode;

		private static readonly Func<Type, CompiledMethods> CreateCompiledMethods;

		private static readonly ThreadsafeTypeKeyHashTable<CompiledMethods> Serializes;

		public static MessagePackSerializerOptions DefaultOptions
		{
			get
			{
				return defaultOptions ?? (defaultOptions = MessagePackSerializerOptions.Standard);
			}
			set
			{
				defaultOptions = value;
			}
		}

		public static void Serialize<T>(IBufferWriter<byte> writer, T value, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			MessagePackWriter messagePackWriter = new MessagePackWriter(writer);
			messagePackWriter.CancellationToken = cancellationToken;
			MessagePackWriter writer2 = messagePackWriter;
			Serialize(ref writer2, value, options);
			writer2.Flush();
		}

		public static void Serialize<T>(ref MessagePackWriter writer, T value, MessagePackSerializerOptions? options = null)
		{
			options = options ?? DefaultOptions;
			bool oldSpec = writer.OldSpec;
			if (options.OldSpec.HasValue)
			{
				writer.OldSpec = options.OldSpec.Value;
			}
			try
			{
				if (options.Compression.IsCompression() && !PrimitiveChecker<T>.IsMessagePackFixedSizePrimitive)
				{
					using (SequencePool.Rental rental = options.SequencePool.Rent())
					{
						Sequence<byte> value2 = rental.Value;
						MessagePackWriter writer2 = writer.Clone(value2);
						options.Resolver.GetFormatterWithVerify<T>().Serialize(ref writer2, value, options);
						writer2.Flush();
						ReadOnlySequence<byte> msgpackUncompressedData = value2;
						ToLZ4BinaryCore(in msgpackUncompressedData, ref writer, options.Compression, options.CompressionMinLength);
						return;
					}
				}
				options.Resolver.GetFormatterWithVerify<T>().Serialize(ref writer, value, options);
			}
			catch (Exception inner)
			{
				throw new MessagePackSerializationException("Failed to serialize " + typeof(T).FullName + " value.", inner);
			}
			finally
			{
				writer.OldSpec = oldSpec;
			}
		}

		public static byte[] Serialize<T>(T value, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			byte[] array = scratchArray;
			if (array == null)
			{
				array = (scratchArray = new byte[65536]);
			}
			options = options ?? DefaultOptions;
			MessagePackWriter messagePackWriter = new MessagePackWriter(options.SequencePool, array);
			messagePackWriter.CancellationToken = cancellationToken;
			MessagePackWriter writer = messagePackWriter;
			Serialize(ref writer, value, options);
			return writer.FlushAndGetArray();
		}

		public static void Serialize<T>(Stream stream, T value, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			options = options ?? DefaultOptions;
			cancellationToken.ThrowIfCancellationRequested();
			using SequencePool.Rental rental = options.SequencePool.Rent();
			Serialize(rental.Value, value, options, cancellationToken);
			try
			{
				ReadOnlySequence<byte>.Enumerator enumerator = rental.Value.AsReadOnlySequence.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ReadOnlyMemory<byte> current = enumerator.Current;
					cancellationToken.ThrowIfCancellationRequested();
					stream.Write(current.Span);
				}
			}
			catch (Exception inner)
			{
				throw new MessagePackSerializationException("Error occurred while writing the serialized data to the stream.", inner);
			}
		}

		public static async Task SerializeAsync<T>(Stream stream, T value, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			options = options ?? DefaultOptions;
			cancellationToken.ThrowIfCancellationRequested();
			using SequencePool.Rental sequenceRental = options.SequencePool.Rent();
			Serialize(sequenceRental.Value, value, options, cancellationToken);
			try
			{
				ReadOnlySequence<byte>.Enumerator enumerator = sequenceRental.Value.AsReadOnlySequence.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ReadOnlyMemory<byte> current = enumerator.Current;
					cancellationToken.ThrowIfCancellationRequested();
					await stream.WriteAsync(current, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				}
			}
			catch (Exception inner)
			{
				throw new MessagePackSerializationException("Error occurred while writing the serialized data to the stream.", inner);
			}
		}

		public static T Deserialize<T>(in ReadOnlySequence<byte> byteSequence, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			MessagePackReader messagePackReader = new MessagePackReader(in byteSequence);
			messagePackReader.CancellationToken = cancellationToken;
			MessagePackReader reader = messagePackReader;
			return Deserialize<T>(ref reader, options);
		}

		public static T Deserialize<T>(ref MessagePackReader reader, MessagePackSerializerOptions? options = null)
		{
			options = options ?? DefaultOptions;
			try
			{
				if (options.Compression.IsCompression())
				{
					using (SequencePool.Rental rental = options.SequencePool.Rent())
					{
						Sequence<byte> value = rental.Value;
						if (TryDecompress(ref reader, value))
						{
							ReadOnlySequence<byte> readOnlySequence = value.AsReadOnlySequence;
							MessagePackReader reader2 = reader.Clone(in readOnlySequence);
							return options.Resolver.GetFormatterWithVerify<T>().Deserialize(ref reader2, options);
						}
						return options.Resolver.GetFormatterWithVerify<T>().Deserialize(ref reader, options);
					}
				}
				return options.Resolver.GetFormatterWithVerify<T>().Deserialize(ref reader, options);
			}
			catch (Exception inner)
			{
				throw new MessagePackSerializationException("Failed to deserialize " + typeof(T).FullName + " value.", inner);
			}
		}

		public static T Deserialize<T>(ReadOnlyMemory<byte> buffer, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			MessagePackReader messagePackReader = new MessagePackReader(buffer);
			messagePackReader.CancellationToken = cancellationToken;
			MessagePackReader reader = messagePackReader;
			return Deserialize<T>(ref reader, options);
		}

		public static T Deserialize<T>(ReadOnlyMemory<byte> buffer, out int bytesRead, CancellationToken cancellationToken = default(CancellationToken))
		{
			return Deserialize<T>(buffer, null, out bytesRead, cancellationToken);
		}

		public static T Deserialize<T>(ReadOnlyMemory<byte> buffer, MessagePackSerializerOptions? options, out int bytesRead, CancellationToken cancellationToken = default(CancellationToken))
		{
			MessagePackReader messagePackReader = new MessagePackReader(buffer);
			messagePackReader.CancellationToken = cancellationToken;
			MessagePackReader reader = messagePackReader;
			T result = Deserialize<T>(ref reader, options);
			bytesRead = buffer.Slice(0, checked((int)reader.Consumed)).Length;
			return result;
		}

		public static T Deserialize<T>(Stream stream, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			options = options ?? DefaultOptions;
			if (TryDeserializeFromMemoryStream<T>(stream, options, cancellationToken, out var result))
			{
				return result;
			}
			using SequencePool.Rental rental = options.SequencePool.Rent();
			Sequence<byte> value = rental.Value;
			try
			{
				int num;
				do
				{
					cancellationToken.ThrowIfCancellationRequested();
					Span<byte> span = value.GetSpan(stream.CanSeek ? checked((int)Math.Min(options.SuggestedContiguousMemorySize, stream.Length - stream.Position)) : 0);
					num = stream.Read(span);
					value.Advance(num);
				}
				while (num > 0);
			}
			catch (Exception inner)
			{
				throw new MessagePackSerializationException("Error occurred while reading from the stream.", inner);
			}
			return DeserializeFromSequenceAndRewindStreamIfPossible<T>(stream, options, value, cancellationToken);
		}

		public static async ValueTask<T> DeserializeAsync<T>(Stream stream, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			if (options == null)
			{
				options = DefaultOptions;
			}
			if (TryDeserializeFromMemoryStream<T>(stream, options, cancellationToken, out var result))
			{
				return result;
			}
			using SequencePool.Rental sequenceRental = options.SequencePool.Rent();
			Sequence<byte> sequence = sequenceRental.Value;
			try
			{
				int num;
				do
				{
					Memory<byte> memory = sequence.GetMemory(stream.CanSeek ? checked((int)Math.Min(options.SuggestedContiguousMemorySize, stream.Length - stream.Position)) : 0);
					num = await stream.ReadAsync(memory, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
					sequence.Advance(num);
				}
				while (num > 0);
			}
			catch (Exception inner)
			{
				throw new MessagePackSerializationException("Error occurred while reading from the stream.", inner);
			}
			return DeserializeFromSequenceAndRewindStreamIfPossible<T>(stream, options, sequence, cancellationToken);
		}

		private static bool TryDeserializeFromMemoryStream<T>(Stream stream, MessagePackSerializerOptions options, CancellationToken cancellationToken, [MaybeNullWhen(false)] out T result)
		{
			cancellationToken.ThrowIfCancellationRequested();
			if (stream is MemoryStream memoryStream && memoryStream.TryGetBuffer(out var buffer))
			{
				result = Deserialize<T>(buffer.AsMemory(checked((int)memoryStream.Position)), options, out var bytesRead, cancellationToken);
				memoryStream.Seek(bytesRead, SeekOrigin.Current);
				return true;
			}
			result = default(T);
			return false;
		}

		private static T DeserializeFromSequenceAndRewindStreamIfPossible<T>(Stream streamToRewind, MessagePackSerializerOptions? options, ReadOnlySequence<byte> sequence, CancellationToken cancellationToken)
		{
			if (streamToRewind == null)
			{
				throw new ArgumentNullException("streamToRewind");
			}
			MessagePackReader messagePackReader = new MessagePackReader(in sequence);
			messagePackReader.CancellationToken = cancellationToken;
			MessagePackReader reader = messagePackReader;
			T result = Deserialize<T>(ref reader, options);
			checked
			{
				if (streamToRewind.CanSeek && !reader.End)
				{
					int num = (int)reader.Sequence.Slice(reader.Position).Length;
					streamToRewind.Seek(-num, SeekOrigin.Current);
				}
				return result;
			}
		}

		private static int LZ4Operation(in ReadOnlySequence<byte> input, Span<byte> output, LZ4Transform lz4Operation)
		{
			byte[] array = null;
			checked
			{
				ReadOnlySpan<byte> input2;
				if (input.IsSingleSegment)
				{
					input2 = input.First.Span;
				}
				else
				{
					array = ArrayPool<byte>.Shared.Rent((int)input.Length);
					BuffersExtensions.CopyTo(in input, array);
					input2 = array.AsSpan(0, (int)input.Length);
				}
				try
				{
					return lz4Operation(input2, output);
				}
				finally
				{
					if (array != null)
					{
						ArrayPool<byte>.Shared.Return(array);
					}
				}
			}
		}

		private static bool TryDecompress(ref MessagePackReader reader, IBufferWriter<byte> writer)
		{
			checked
			{
				if (!reader.End)
				{
					Span<byte> span;
					if (reader.NextMessagePackType == MessagePackType.Extension && reader.CreatePeekReader().ReadExtensionFormatHeader().TypeCode == 99)
					{
						ReadOnlySequence<byte> readOnlySequence = reader.ReadExtensionFormat().Data;
						MessagePackReader messagePackReader = new MessagePackReader(in readOnlySequence);
						int num = messagePackReader.ReadInt32();
						readOnlySequence = messagePackReader.Sequence;
						ReadOnlySequence<byte> input = readOnlySequence.Slice(messagePackReader.Position);
						span = writer.GetSpan(num);
						Span<byte> output = span.Slice(0, num);
						int count = LZ4Operation(in input, output, LZ4CodecDecode);
						writer.Advance(count);
						return true;
					}
					if (reader.NextMessagePackType == MessagePackType.Array)
					{
						MessagePackReader messagePackReader2 = reader.CreatePeekReader();
						int num2 = messagePackReader2.ReadArrayHeader();
						if (num2 != 0 && messagePackReader2.NextMessagePackType == MessagePackType.Extension && messagePackReader2.ReadExtensionFormatHeader().TypeCode == 98)
						{
							reader = messagePackReader2;
							int num3 = num2 - 1;
							int[] array = ArrayPool<int>.Shared.Rent(num3);
							try
							{
								for (int i = 0; i < num3; i++)
								{
									array[i] = reader.ReadInt32();
								}
								for (int j = 0; j < num3; j++)
								{
									int num4 = array[j];
									ReadOnlySequence<byte> input2 = reader.ReadBytes() ?? throw MessagePackSerializationException.ThrowUnexpectedNilWhileDeserializing<ReadOnlySequence<byte>>();
									span = writer.GetSpan(num4);
									Span<byte> output2 = span.Slice(0, num4);
									int count2 = LZ4Operation(in input2, output2, LZ4CodecDecode);
									writer.Advance(count2);
								}
								return true;
							}
							finally
							{
								ArrayPool<int>.Shared.Return(array);
							}
						}
					}
				}
				return false;
			}
		}

		private static void ToLZ4BinaryCore(in ReadOnlySequence<byte> msgpackUncompressedData, ref MessagePackWriter writer, MessagePackCompression compression, int minCompressionSize)
		{
			if (msgpackUncompressedData.Length < minCompressionSize)
			{
				writer.WriteRaw(in msgpackUncompressedData);
				return;
			}
			checked
			{
				switch (compression)
				{
				case MessagePackCompression.Lz4Block:
				{
					int minimumLength = LZ4Codec.MaximumOutputLength((int)msgpackUncompressedData.Length);
					byte[] array = ArrayPool<byte>.Shared.Rent(minimumLength);
					try
					{
						int num5 = LZ4Operation(in msgpackUncompressedData, array, LZ4CodecEncode);
						writer.WriteExtensionFormatHeader(new ExtensionHeader(99, 5 + (uint)num5));
						writer.WriteInt32((int)msgpackUncompressedData.Length);
						writer.WriteRaw(array.AsSpan(0, num5));
						break;
					}
					finally
					{
						ArrayPool<byte>.Shared.Return(array);
					}
				}
				case MessagePackCompression.Lz4BlockArray:
				{
					int num = 0;
					int num2 = 0;
					ReadOnlySequence<byte>.Enumerator enumerator = msgpackUncompressedData.GetEnumerator();
					while (enumerator.MoveNext())
					{
						ReadOnlyMemory<byte> current = enumerator.Current;
						num++;
						num2 += GetUInt32WriteSize((uint)current.Length);
					}
					writer.WriteArrayHeader(num + 1);
					writer.WriteExtensionFormatHeader(new ExtensionHeader(98, num2));
					enumerator = msgpackUncompressedData.GetEnumerator();
					while (enumerator.MoveNext())
					{
						writer.Write(enumerator.Current.Length);
					}
					enumerator = msgpackUncompressedData.GetEnumerator();
					while (enumerator.MoveNext())
					{
						ReadOnlyMemory<byte> current2 = enumerator.Current;
						int num3 = LZ4Codec.MaximumOutputLength(current2.Length);
						Span<byte> span = writer.GetSpan(num3 + 5);
						int num4 = LZ4Codec.Encode(current2.Span, span.Slice(5, span.Length - 5));
						WriteBin32Header((uint)num4, span);
						writer.Advance(num4 + 5);
					}
					break;
				}
				default:
					throw new ArgumentException("Invalid MessagePackCompression Code. Code:" + compression);
				}
			}
		}

		private static int GetUInt32WriteSize(uint value)
		{
			if (value <= 127)
			{
				return 1;
			}
			if (value <= 255)
			{
				return 2;
			}
			if (value <= 65535)
			{
				return 3;
			}
			return 5;
		}

		private static void WriteBin32Header(uint value, Span<byte> span)
		{
			span[0] = 198;
			span[4] = (byte)value;
			span[3] = (byte)(value >> 8);
			span[2] = (byte)(value >> 16);
			span[1] = (byte)(value >> 24);
		}

		private static bool IsMessagePackFixedSizePrimitiveTypeHelper(Type type)
		{
			if (!(type == typeof(short)) && !(type == typeof(int)) && !(type == typeof(long)) && !(type == typeof(ushort)) && !(type == typeof(uint)) && !(type == typeof(ulong)) && !(type == typeof(float)) && !(type == typeof(double)) && !(type == typeof(bool)) && !(type == typeof(byte)) && !(type == typeof(sbyte)))
			{
				return type == typeof(char);
			}
			return true;
		}

		public static void SerializeToJson<T>(TextWriter textWriter, T obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			options = options ?? DefaultOptions;
			using SequencePool.Rental rental = options.SequencePool.Rent();
			MessagePackWriter messagePackWriter = new MessagePackWriter(rental.Value);
			messagePackWriter.CancellationToken = cancellationToken;
			MessagePackWriter writer = messagePackWriter;
			Serialize(ref writer, obj, options);
			writer.Flush();
			ReadOnlySequence<byte> readOnlySequence = rental.Value;
			MessagePackReader messagePackReader = new MessagePackReader(in readOnlySequence);
			messagePackReader.CancellationToken = cancellationToken;
			MessagePackReader reader = messagePackReader;
			ConvertToJson(ref reader, textWriter, options);
		}

		public static string SerializeToJson<T>(T obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			StringWriter stringWriter = new StringWriter();
			SerializeToJson(stringWriter, obj, options, cancellationToken);
			return stringWriter.ToString();
		}

		public static string ConvertToJson(ReadOnlyMemory<byte> bytes, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			ReadOnlySequence<byte> bytes2 = new ReadOnlySequence<byte>(bytes);
			return ConvertToJson(in bytes2, options, cancellationToken);
		}

		public static string ConvertToJson(in ReadOnlySequence<byte> bytes, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			StringWriter stringWriter = new StringWriter();
			MessagePackReader messagePackReader = new MessagePackReader(in bytes);
			messagePackReader.CancellationToken = cancellationToken;
			MessagePackReader reader = messagePackReader;
			ConvertToJson(ref reader, stringWriter, options);
			return stringWriter.ToString();
		}

		public static void ConvertToJson(ref MessagePackReader reader, TextWriter jsonWriter, MessagePackSerializerOptions? options = null)
		{
			if (reader.End)
			{
				return;
			}
			options = options ?? DefaultOptions;
			try
			{
				if (options.Compression.IsCompression())
				{
					using (SequencePool.Rental rental = options.SequencePool.Rent())
					{
						if (TryDecompress(ref reader, rental.Value))
						{
							ReadOnlySequence<byte> readOnlySequence = rental.Value;
							MessagePackReader messagePackReader = new MessagePackReader(in readOnlySequence);
							messagePackReader.CancellationToken = reader.CancellationToken;
							MessagePackReader reader2 = messagePackReader;
							if (!reader2.End)
							{
								ToJsonCore(ref reader2, jsonWriter, options);
							}
						}
						else
						{
							ToJsonCore(ref reader, jsonWriter, options);
						}
						return;
					}
				}
				ToJsonCore(ref reader, jsonWriter, options);
			}
			catch (Exception inner)
			{
				throw new MessagePackSerializationException("Error occurred while translating msgpack to JSON.", inner);
			}
		}

		public static void ConvertFromJson(string str, ref MessagePackWriter writer, MessagePackSerializerOptions? options = null)
		{
			using StringReader reader = new StringReader(str);
			ConvertFromJson(reader, ref writer, options);
		}

		public static byte[] ConvertFromJson(string str, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			options = options ?? DefaultOptions;
			using SequencePool.Rental rental = options.SequencePool.Rent();
			MessagePackWriter messagePackWriter = new MessagePackWriter(rental.Value);
			messagePackWriter.CancellationToken = cancellationToken;
			MessagePackWriter writer = messagePackWriter;
			using (StringReader reader = new StringReader(str))
			{
				ConvertFromJson(reader, ref writer, options);
			}
			writer.Flush();
			ReadOnlySequence<byte> sequence = rental.Value.AsReadOnlySequence;
			return BuffersExtensions.ToArray(in sequence);
		}

		public static void ConvertFromJson(TextReader reader, ref MessagePackWriter writer, MessagePackSerializerOptions? options = null)
		{
			options = options ?? DefaultOptions;
			if (options.Compression.IsCompression())
			{
				using (SequencePool.Rental rental = options.SequencePool.Rent())
				{
					MessagePackWriter writer2 = writer.Clone(rental.Value);
					using (TinyJsonReader jr = new TinyJsonReader(reader, disposeInnerReader: false))
					{
						FromJsonCore(jr, ref writer2, options);
					}
					writer2.Flush();
					ReadOnlySequence<byte> msgpackUncompressedData = rental.Value;
					ToLZ4BinaryCore(in msgpackUncompressedData, ref writer, options.Compression, options.CompressionMinLength);
					return;
				}
			}
			using TinyJsonReader jr2 = new TinyJsonReader(reader, disposeInnerReader: false);
			FromJsonCore(jr2, ref writer, options);
		}

		private static uint FromJsonCore(TinyJsonReader jr, ref MessagePackWriter writer, MessagePackSerializerOptions options)
		{
			uint num = 0u;
			checked
			{
				while (jr.Read())
				{
					switch (jr.TokenType)
					{
					case TinyJsonToken.StartObject:
					{
						using (SequencePool.Rental rental2 = options.SequencePool.Rent())
						{
							MessagePackWriter writer3 = writer.Clone(rental2.Value);
							uint num2 = FromJsonCore(jr, ref writer3, options);
							writer3.Flush();
							num2 = unchecked(num2 / 2);
							writer.WriteMapHeader(num2);
							ReadOnlySequence<byte> rawMessagePackBlock = rental2.Value;
							writer.WriteRaw(in rawMessagePackBlock);
						}
						num++;
						break;
					}
					case TinyJsonToken.EndObject:
						return num;
					case TinyJsonToken.StartArray:
					{
						using (SequencePool.Rental rental = options.SequencePool.Rent())
						{
							MessagePackWriter writer2 = writer.Clone(rental.Value);
							uint count = FromJsonCore(jr, ref writer2, options);
							writer2.Flush();
							writer.WriteArrayHeader(count);
							ReadOnlySequence<byte> rawMessagePackBlock = rental.Value;
							writer.WriteRaw(in rawMessagePackBlock);
						}
						num++;
						break;
					}
					case TinyJsonToken.EndArray:
						return num;
					case TinyJsonToken.Number:
						switch (jr.ValueType)
						{
						case ValueType.Double:
							writer.Write(jr.DoubleValue);
							break;
						case ValueType.Long:
							writer.Write(jr.LongValue);
							break;
						case ValueType.ULong:
							writer.Write(jr.ULongValue);
							break;
						case ValueType.Decimal:
							DecimalFormatter.Instance.Serialize(ref writer, jr.DecimalValue, options);
							break;
						}
						num++;
						break;
					case TinyJsonToken.String:
						writer.Write(jr.StringValue);
						num++;
						break;
					case TinyJsonToken.True:
						writer.Write(value: true);
						num++;
						break;
					case TinyJsonToken.False:
						writer.Write(value: false);
						num++;
						break;
					case TinyJsonToken.Null:
						writer.WriteNil();
						num++;
						break;
					}
				}
				return num;
			}
		}

		private static void ToJsonCore(ref MessagePackReader reader, TextWriter writer, MessagePackSerializerOptions options)
		{
			checked
			{
				switch (reader.NextMessagePackType)
				{
				case MessagePackType.Integer:
					if (MessagePackCode.IsSignedInteger(reader.NextCode))
					{
						writer.Write(reader.ReadInt64().ToString(CultureInfo.InvariantCulture));
					}
					else
					{
						writer.Write(reader.ReadUInt64().ToString(CultureInfo.InvariantCulture));
					}
					break;
				case MessagePackType.Boolean:
					writer.Write(reader.ReadBoolean() ? "true" : "false");
					break;
				case MessagePackType.Float:
					if (reader.NextCode == 202)
					{
						writer.Write(reader.ReadSingle().ToString(CultureInfo.InvariantCulture));
					}
					else
					{
						writer.Write(reader.ReadDouble().ToString(CultureInfo.InvariantCulture));
					}
					break;
				case MessagePackType.String:
					WriteJsonString(reader.ReadString(), writer);
					break;
				case MessagePackType.Binary:
				{
					ArraySegment<byte> arraySegment = ByteArraySegmentFormatter.Instance.Deserialize(ref reader, options);
					writer.Write("\"" + Convert.ToBase64String(arraySegment.Array ?? Array.Empty<byte>(), arraySegment.Offset, arraySegment.Count) + "\"");
					break;
				}
				case MessagePackType.Array:
				{
					int num2 = reader.ReadArrayHeader();
					options.Security.DepthStep(ref reader);
					try
					{
						writer.Write("[");
						for (int i = 0; i < num2; i++)
						{
							ToJsonCore(ref reader, writer, options);
							if (i != num2 - 1)
							{
								writer.Write(",");
							}
						}
						writer.Write("]");
						break;
					}
					finally
					{
						reader.Depth--;
					}
				}
				case MessagePackType.Map:
				{
					int num3 = reader.ReadMapHeader();
					options.Security.DepthStep(ref reader);
					try
					{
						writer.Write("{");
						for (int j = 0; j < num3; j++)
						{
							MessagePackType nextMessagePackType2 = reader.NextMessagePackType;
							if (nextMessagePackType2 == MessagePackType.String || nextMessagePackType2 == MessagePackType.Binary)
							{
								ToJsonCore(ref reader, writer, options);
							}
							else
							{
								writer.Write("\"");
								ToJsonCore(ref reader, writer, options);
								writer.Write("\"");
							}
							writer.Write(":");
							ToJsonCore(ref reader, writer, options);
							if (j != num3 - 1)
							{
								writer.Write(",");
							}
						}
						writer.Write("}");
						break;
					}
					finally
					{
						reader.Depth--;
					}
				}
				case MessagePackType.Extension:
				{
					ExtensionHeader header = reader.ReadExtensionFormatHeader();
					if (header.TypeCode == -1)
					{
						DateTime dateTime = reader.ReadDateTime(header);
						writer.Write("\"");
						writer.Write(dateTime.ToString("o", CultureInfo.InvariantCulture));
						writer.Write("\"");
					}
					else if (header.TypeCode == 100)
					{
						StringBuilder stringBuilder = new StringBuilder();
						StringBuilder stringBuilder2 = new StringBuilder();
						SequencePosition position = reader.Position;
						ToJsonCore(ref reader, new StringWriter(stringBuilder2), options);
						int num = (int)reader.Sequence.Slice(position, reader.Position).Length;
						if (header.Length > num)
						{
							MessagePackType nextMessagePackType = reader.NextMessagePackType;
							if (nextMessagePackType != MessagePackType.Array && nextMessagePackType != MessagePackType.Map)
							{
								stringBuilder.Append("{");
							}
							ToJsonCore(ref reader, new StringWriter(stringBuilder), options);
							if (nextMessagePackType != MessagePackType.Array)
							{
								stringBuilder2.Insert(0, "\"$type\":");
							}
							if (nextMessagePackType != MessagePackType.Array && nextMessagePackType != MessagePackType.Map)
							{
								stringBuilder.Append("}");
							}
							if (stringBuilder.Length > 2)
							{
								stringBuilder2.Append(",");
							}
							stringBuilder.Insert(1, stringBuilder2.ToString());
							writer.Write(stringBuilder.ToString());
						}
						else
						{
							writer.Write("{\"$type\":" + stringBuilder2.ToString() + "}");
						}
					}
					else
					{
						ReadOnlySequence<byte> sequence = reader.ReadRaw(header.Length);
						writer.Write("[");
						writer.Write(header.TypeCode);
						writer.Write(",");
						writer.Write("\"");
						writer.Write(Convert.ToBase64String(BuffersExtensions.ToArray(in sequence)));
						writer.Write("\"");
						writer.Write("]");
					}
					break;
				}
				case MessagePackType.Nil:
					reader.Skip();
					writer.Write("null");
					break;
				default:
					throw new MessagePackSerializationException($"code is invalid. code: {reader.NextCode} format: {MessagePackCode.ToFormatName(reader.NextCode)}");
				}
			}
		}

		private static void WriteJsonString(string value, TextWriter builder)
		{
			builder.Write('"');
			int length = value.Length;
			for (int i = 0; i < length; i = checked(i + 1))
			{
				char c = value[i];
				switch (c)
				{
				case '"':
					builder.Write("\\\"");
					break;
				case '\\':
					builder.Write("\\\\");
					break;
				case '\b':
					builder.Write("\\b");
					break;
				case '\f':
					builder.Write("\\f");
					break;
				case '\n':
					builder.Write("\\n");
					break;
				case '\r':
					builder.Write("\\r");
					break;
				case '\t':
					builder.Write("\\t");
					break;
				default:
					builder.Write(c);
					break;
				}
			}
			builder.Write('"');
		}

		static MessagePackSerializer()
		{
			LZ4CodecEncode = LZ4Codec.Encode;
			LZ4CodecDecode = LZ4Codec.Decode;
			Serializes = new ThreadsafeTypeKeyHashTable<CompiledMethods>(64);
			CreateCompiledMethods = (Type t) => new CompiledMethods(t);
		}

		public static void Serialize(Type type, ref MessagePackWriter writer, object? obj, MessagePackSerializerOptions? options = null)
		{
			GetOrAdd(type).Serialize_MessagePackWriter_T_Options(ref writer, obj, options);
		}

		public static void Serialize(Type type, IBufferWriter<byte> writer, object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			GetOrAdd(type).Serialize_IBufferWriter_T_Options_CancellationToken(writer, obj, options, cancellationToken);
		}

		public static byte[] Serialize(Type type, object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetOrAdd(type).Serialize_T_Options(obj, options, cancellationToken);
		}

		public static void Serialize(Type type, Stream stream, object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			GetOrAdd(type).Serialize_Stream_T_Options_CancellationToken(stream, obj, options, cancellationToken);
		}

		public static Task SerializeAsync(Type type, Stream stream, object? obj, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetOrAdd(type).SerializeAsync_Stream_T_Options_CancellationToken(stream, obj, options, cancellationToken);
		}

		public static object? Deserialize(Type type, ref MessagePackReader reader, MessagePackSerializerOptions? options = null)
		{
			return GetOrAdd(type).Deserialize_MessagePackReader_Options(ref reader, options);
		}

		public static object? Deserialize(Type type, Stream stream, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetOrAdd(type).Deserialize_Stream_Options_CancellationToken(stream, options, cancellationToken);
		}

		public static ValueTask<object?> DeserializeAsync(Type type, Stream stream, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetOrAdd(type).DeserializeAsync_Stream_Options_CancellationToken(stream, options, cancellationToken);
		}

		public static object? Deserialize(Type type, ReadOnlyMemory<byte> bytes, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetOrAdd(type).Deserialize_ReadOnlyMemory_Options(bytes, options, cancellationToken);
		}

		public static object? Deserialize(Type type, ReadOnlySequence<byte> bytes, MessagePackSerializerOptions? options = null, CancellationToken cancellationToken = default(CancellationToken))
		{
			return GetOrAdd(type).Deserialize_ReadOnlySequence_Options_CancellationToken(bytes, options, cancellationToken);
		}

		private static void SerializeSemiGeneric<T>(ref MessagePackWriter writer, object valueObject, MessagePackSerializerOptions? options = null)
		{
			Serialize(ref writer, (T)valueObject, options);
		}

		private static object? DeserializeSemiGeneric<T>(ref MessagePackReader reader, MessagePackSerializerOptions? options = null)
		{
			return Deserialize<T>(ref reader, options);
		}

		private static async ValueTask<object?> DeserializeObjectAsync<T>(Stream stream, MessagePackSerializerOptions options, CancellationToken cancellationToken)
		{
			return await DeserializeAsync<T>(stream, options, cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
		}

		private static CompiledMethods GetOrAdd(Type type)
		{
			return Serializes.GetOrAdd(type, CreateCompiledMethods);
		}
	}
	public class MessagePackStreamReader : IDisposable
	{
		private readonly Stream stream;

		private readonly bool leaveOpen;

		private SequencePool.Rental sequenceRental;

		private SequencePosition? endOfLastMessage;

		public ReadOnlySequence<byte> RemainingBytes
		{
			get
			{
				if (!endOfLastMessage.HasValue)
				{
					return ReadData.AsReadOnlySequence;
				}
				return ReadData.AsReadOnlySequence.Slice(endOfLastMessage.Value);
			}
		}

		private Sequence<byte> ReadData => sequenceRental.Value;

		public async ValueTask<int> ReadArrayHeaderAsync(CancellationToken cancellationToken)
		{
			RecycleLastMessage();
			cancellationToken.ThrowIfCancellationRequested();
			int length;
			while (!TryReadArrayHeader(out length))
			{
				if (!(await TryReadMoreDataAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					throw new EndOfStreamException("The stream ended before a map header could be found.");
				}
			}
			return length;
		}

		public async IAsyncEnumerable<ReadOnlySequence<byte>> ReadArrayAsync([EnumeratorCancellation] CancellationToken cancellationToken)
		{
			RecycleLastMessage();
			cancellationToken.ThrowIfCancellationRequested();
			int length;
			while (!TryReadArrayHeader(out length))
			{
				if (!(await TryReadMoreDataAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					throw new EndOfStreamException("The stream ended before an array header could be found.");
				}
			}
			for (int i = 0; i < length; i = checked(i + 1))
			{
				ReadOnlySequence<byte>? readOnlySequence = await ReadAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false);
				if (!readOnlySequence.HasValue)
				{
					throw new EndOfStreamException("Stream ended before all elements were read.");
				}
				yield return readOnlySequence.Value;
			}
		}

		private bool TryReadArrayHeader(out int length)
		{
			if (ReadData.Length > 0)
			{
				ReadOnlySequence<byte> readOnlySequence = ReadData;
				MessagePackReader messagePackReader = new MessagePackReader(in readOnlySequence);
				if (messagePackReader.TryReadArrayHeader(out length))
				{
					endOfLastMessage = messagePackReader.Position;
					return true;
				}
			}
			length = 0;
			return false;
		}

		public async ValueTask<int> ReadMapHeaderAsync(CancellationToken cancellationToken)
		{
			RecycleLastMessage();
			cancellationToken.ThrowIfCancellationRequested();
			int count;
			while (!TryReadMapHeader(out count))
			{
				if (!(await TryReadMoreDataAsync(cancellationToken).ConfigureAwait(continueOnCapturedContext: false)))
				{
					throw new EndOfStreamException("The stream ended before a map header could be found.");
				}
			}
			return count;
		}

		private bool TryReadMapHeader(out int count)
		{
			if (ReadData.Length > 0)
			{
				ReadOnlySequence<byte> readOnlySequence = ReadData;
				MessagePackReader messagePackReader = new MessagePackReader(in readOnlySequence);
				if (messagePackReader.TryReadMapHeader(out count))
				{
					endOfLastMessage = messagePackReader.Position;
					return true;
				}
			}
			count = 0;
			return false;
		}

		public MessagePackStreamReader(Stream stream)
			: this(stream, leaveOpen: false)
		{
		}

		public MessagePackStreamReader(Stream stream, bool leaveOpen)
			: this(stream, leaveOpen, SequencePool.Shared)
		{
		}

		public MessagePackStreamReader(Stream stream, bool leaveOpen, SequencePool sequencePool)
		{
			if (sequencePool == null)
			{
				throw new ArgumentNullException("sequencePool");
			}
			this.stream = stream ?? throw new ArgumentNullException("stream");
			this.leaveOpen = leaveOpen;
			sequenceRental = sequencePool.Rent();
		}

		public async ValueTask<ReadOnlySequence<byte>?> ReadAsync(CancellationToken cancellationToken)
		{
			RecycleLastMessage();
			do
			{
				cancellationToken.ThrowIfCancellationRequested();
				if (TryReadNextMessage(out var completeMessage))
				{
					return completeMessage;
				}
			}
			while (await TryReadMoreDataAsync(cancellationToken)