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.Diagnostics.Tracing;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Linq.Expressions;
using System.Net;
using System.Net.Sockets;
using System.Numerics;
using System.Numerics.Hashing;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Xml;
using System.Xml.Serialization;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using FxResources.System.Buffers;
using FxResources.System.Collections.Immutable;
using FxResources.System.Memory;
using HarmonyLib;
using JetBrains.Annotations;
using Microsoft.CodeAnalysis;
using ProtoBuf;
using ProtoBuf.Compiler;
using ProtoBuf.Extensions;
using ProtoBuf.Internal;
using ProtoBuf.Internal.Serializers;
using ProtoBuf.Meta;
using ProtoBuf.Serializers;
using ProtoBuf.WellKnownTypes;
using ServerSync;
using Splatform;
using Steamworks;
using TMPro;
using UnityEngine;
using YamlDotNet.Core;
using YamlDotNet.Core.Events;
using YamlDotNet.Core.Tokens;
using YamlDotNet.Helpers;
using YamlDotNet.Serialization;
using YamlDotNet.Serialization.BufferedDeserialization;
using YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators;
using YamlDotNet.Serialization.Callbacks;
using YamlDotNet.Serialization.Converters;
using YamlDotNet.Serialization.EventEmitters;
using YamlDotNet.Serialization.NamingConventions;
using YamlDotNet.Serialization.NodeDeserializers;
using YamlDotNet.Serialization.NodeTypeResolvers;
using YamlDotNet.Serialization.ObjectFactories;
using YamlDotNet.Serialization.ObjectGraphTraversalStrategies;
using YamlDotNet.Serialization.ObjectGraphVisitors;
using YamlDotNet.Serialization.Schemas;
using YamlDotNet.Serialization.TypeInspectors;
using YamlDotNet.Serialization.TypeResolvers;
using YamlDotNet.Serialization.Utilities;
using YamlDotNet.Serialization.ValueDeserializers;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ServerCharacters")]
[assembly: AssemblyDescription("https://valheim.thunderstore.io/package/Smoothbrain/ServerCharacters")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyProduct("ServerCharacters")]
[assembly: AssemblyCopyright("Copyright ©  2021")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("B6DC411F-BB68-4745-BA9E-ADFEAF8C7F0E")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyCompany("")]
[assembly: TargetFramework(".NETFramework,Version=v4.8", FrameworkDisplayName = ".NET Framework 4.8")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<b7e2de72-b000-46fb-a762-da1e7ee8ccff>Embedded]
	internal sealed class <b7e2de72-b000-46fb-a762-da1e7ee8ccff>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[<b7e2de72-b000-46fb-a762-da1e7ee8ccff>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <ac6d2775-cef6-4d66-9819-032e899cd913>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <ac6d2775-cef6-4d66-9819-032e899cd913>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <ac6d2775-cef6-4d66-9819-032e899cd913>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<b7e2de72-b000-46fb-a762-da1e7ee8ccff>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace ServerCharacters
{
	public static class ClientSide
	{
		[HarmonyPatch(typeof(Skills), "ResetSkill")]
		public class SaveLastSkillReset
		{
			public static SkillType last = (SkillType)999;

			[UsedImplicitly]
			public static void Finalizer(SkillType skillType)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				last = skillType;
			}
		}

		[HarmonyPatch(typeof(Console), "Print")]
		public class SilenceConsole
		{
			public static bool silence;

			[UsedImplicitly]
			public static bool Prefix()
			{
				return !silence;
			}
		}

		[HarmonyPatch(typeof(Terminal), "InitTerminal")]
		public class AddChatCommands
		{
			[Serializable]
			[CompilerGenerated]
			private sealed class <>c
			{
				public static readonly <>c <>9 = new <>c();

				public static Func<KeyValuePair<SkillType, Skill>, SkillType> <>9__0_3;

				public static Func<KeyValuePair<SkillType, Skill>, Skill> <>9__0_4;

				public static ConsoleEvent <>9__0_0;

				public static ConsoleOptionsFetcher <>9__0_1;

				internal void <Postfix>b__0_0(ConsoleEventArgs args)
				{
					//IL_0067: Unknown result type (might be due to invalid IL or missing references)
					//IL_0071: Invalid comparison between Unknown and I4
					//IL_023a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0244: Invalid comparison between Unknown and I4
					//IL_081e: Unknown result type (might be due to invalid IL or missing references)
					<>c__DisplayClass0_0 <>c__DisplayClass0_ = new <>c__DisplayClass0_0
					{
						args = args
					};
					if (!ServerCharacters.configSync.IsAdmin)
					{
						<>c__DisplayClass0_.args.Context.AddString("You are not an admin on this server.");
					}
					else if (<>c__DisplayClass0_.args.Length >= 3 && <>c__DisplayClass0_.args[1] == "resetskill")
					{
						if ((int)<Postfix>g__GetSkillType|0_2(<>c__DisplayClass0_.args[2]) == 999)
						{
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[2] + " is not a valid skill.");
						}
						else if (<>c__DisplayClass0_.args.Length > 3)
						{
							string text = <>c__DisplayClass0_.args[3];
							int num = 4;
							if (text.StartsWith("\"", StringComparison.Ordinal))
							{
								text = text.Substring(1);
								while (num < <>c__DisplayClass0_.args.Length && !text.EndsWith("\"", StringComparison.Ordinal))
								{
									text = text + " " + <>c__DisplayClass0_.args[num++];
								}
								text = text.Substring(0, text.Length - 1);
							}
							ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters ResetSkill", new object[3]
							{
								<>c__DisplayClass0_.args[2],
								text,
								(<>c__DisplayClass0_.args.Length > num) ? <>c__DisplayClass0_.args[num] : "0"
							});
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[2] + " has been reset for " + text + ".");
						}
						else
						{
							ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters ResetSkill", new object[3]
							{
								<>c__DisplayClass0_.args[2],
								"",
								"0"
							});
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[2] + " has been reset for everyone.");
						}
					}
					else if (<>c__DisplayClass0_.args.Length >= 3 && <>c__DisplayClass0_.args[1] == "raiseskill")
					{
						if ((int)<Postfix>g__GetSkillType|0_2(<>c__DisplayClass0_.args[2]) == 999)
						{
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[2] + " is not a valid skill.");
						}
						else if (<>c__DisplayClass0_.args.Length > 4)
						{
							string text2 = <>c__DisplayClass0_.args[4];
							int num2 = 5;
							if (text2.StartsWith("\"", StringComparison.Ordinal))
							{
								text2 = text2.Substring(1);
								while (num2 < <>c__DisplayClass0_.args.Length && !text2.EndsWith("\"", StringComparison.Ordinal))
								{
									text2 = text2 + " " + <>c__DisplayClass0_.args[num2++];
								}
								text2 = text2.Substring(0, text2.Length - 1);
							}
							ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters RaiseSkill", new object[4]
							{
								<>c__DisplayClass0_.args[2],
								int.Parse(<>c__DisplayClass0_.args[3]),
								text2,
								(<>c__DisplayClass0_.args.Length > num2) ? <>c__DisplayClass0_.args[num2] : "0"
							});
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[2] + " has been raised by " + <>c__DisplayClass0_.args[3] + " for " + text2 + ".");
						}
						else
						{
							ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters RaiseSkill", new object[4]
							{
								<>c__DisplayClass0_.args[2],
								int.Parse(<>c__DisplayClass0_.args[3]),
								"",
								"0"
							});
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[2] + " has been raised by " + <>c__DisplayClass0_.args[3] + " for everyone.");
						}
					}
					else if (<>c__DisplayClass0_.args.Length >= 3 && <>c__DisplayClass0_.args[1] == "giveitem")
					{
						if (ObjectDB.instance.GetItemPrefab(<>c__DisplayClass0_.args[2]) == null)
						{
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[2] + " is not a valid item.");
						}
						else if (<>c__DisplayClass0_.args.Length > 4)
						{
							string text3 = <>c__DisplayClass0_.args[4];
							int num3 = 5;
							if (text3.StartsWith("\"", StringComparison.Ordinal))
							{
								text3 = text3.Substring(1);
								while (num3 < <>c__DisplayClass0_.args.Length && !text3.EndsWith("\"", StringComparison.Ordinal))
								{
									text3 = text3 + " " + <>c__DisplayClass0_.args[num3++];
								}
								text3 = text3.Substring(0, text3.Length - 1);
							}
							ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters GiveItem", new object[4]
							{
								<>c__DisplayClass0_.args[2],
								int.Parse(<>c__DisplayClass0_.args[3]),
								text3,
								(<>c__DisplayClass0_.args.Length > num3) ? <>c__DisplayClass0_.args[num3] : "0"
							});
							<>c__DisplayClass0_.args.Context.AddString(<>c__DisplayClass0_.args[3] + "x " + <>c__DisplayClass0_.args[2] + " has been given to " + text3 + ", if their inventory isn't full.");
						}
						else
						{
							<>c__DisplayClass0_.args.Context.AddString("Please specify a target player.");
						}
					}
					else if (<>c__DisplayClass0_.args.Length >= 3 && <>c__DisplayClass0_.args[1] == "teleport")
					{
						string text4 = <>c__DisplayClass0_.args[2];
						int num4 = 3;
						if (text4.StartsWith("\"", StringComparison.Ordinal))
						{
							text4 = text4.Substring(1);
							while (num4 < <>c__DisplayClass0_.args.Length && !text4.EndsWith("\"", StringComparison.Ordinal))
							{
								text4 = text4 + " " + <>c__DisplayClass0_.args[num4++];
							}
							text4 = text4.Substring(0, text4.Length - 1);
						}
						ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters GetPlayerPos", new object[2]
						{
							text4,
							(<>c__DisplayClass0_.args.Length > num4) ? <>c__DisplayClass0_.args[num4] : "0"
						});
						((MonoBehaviour)ServerCharacters.selfReference).StartCoroutine(<>c__DisplayClass0_.<Postfix>g__AwaitResponse|5());
					}
					else if (<>c__DisplayClass0_.args.Length >= 3 && <>c__DisplayClass0_.args[1] == "summon")
					{
						string text5 = <>c__DisplayClass0_.args[2];
						int num5 = 3;
						if (text5.StartsWith("\"", StringComparison.Ordinal))
						{
							text5 = text5.Substring(1);
							while (num5 < <>c__DisplayClass0_.args.Length && !text5.EndsWith("\"", StringComparison.Ordinal))
							{
								text5 = text5 + " " + <>c__DisplayClass0_.args[num5++];
							}
							text5 = text5.Substring(0, text5.Length - 1);
						}
						ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters SendOwnPos", new object[3]
						{
							text5,
							(<>c__DisplayClass0_.args.Length > num5) ? <>c__DisplayClass0_.args[num5] : "0",
							((Component)Player.m_localPlayer).transform.position
						});
						((MonoBehaviour)ServerCharacters.selfReference).StartCoroutine(<>c__DisplayClass0_.<Postfix>g__AwaitResponse|7());
					}
					else
					{
						<>c__DisplayClass0_.args.Context.AddString("ServerCharacters console commands - use 'ServerCharacters' followed by one of the following options.");
						<>c__DisplayClass0_.args.Context.AddString("resetskill [skillname] [playername] [id] - resets the skill for the specified player. Steam / Xbox ID is optional and only required, if multiple players have the same name. If no name is provided, the skill is reset for every character on the server, online and offline.");
						<>c__DisplayClass0_.args.Context.AddString("raiseskill [skillname] [level] [playername] [id] - raises the skill for the specified player by the specified level. Steam / Xbox ID is optional and only required, if multiple players have the same name. If no name is provided, the skill is raised for every character on the server, online and offline.");
						<>c__DisplayClass0_.args.Context.AddString("teleport [playername] [steamid] - teleports you to the specified player. Quote names with a space. Steam / Xbox ID is optional and only required, if multiple players have the same name.");
						<>c__DisplayClass0_.args.Context.AddString("summon [playername] [steamid] - teleports the specified player to you. Quote names with a space. Steam / Xbox ID is optional and only required, if multiple players have the same name.");
						<>c__DisplayClass0_.args.Context.AddString("giveitem [itemname] [quantity] [playername] [id] - adds the specified item to the specified players inventory in the specified quantity. Quote names with a space. Steam / Xbox ID is optional and only required, if multiple players have the same name. Will fail, if their inventory is full.");
					}
				}

				internal SkillType <Postfix>b__0_3(KeyValuePair<SkillType, Skill> kv)
				{
					//IL_0002: Unknown result type (might be due to invalid IL or missing references)
					return kv.Key;
				}

				internal Skill <Postfix>b__0_4(KeyValuePair<SkillType, Skill> kv)
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0011: Unknown result type (might be due to invalid IL or missing references)
					//IL_0023: Unknown result type (might be due to invalid IL or missing references)
					//IL_0036: Expected O, but got Unknown
					return new Skill(kv.Value.m_info)
					{
						m_accumulator = kv.Value.m_accumulator,
						m_level = kv.Value.m_level
					};
				}

				internal List<string> <Postfix>b__0_1()
				{
					return new List<string> { "resetskill", "teleport", "summon", "raiseskill", "giveitem" };
				}
			}

			[CompilerGenerated]
			private sealed class <>c__DisplayClass0_0
			{
				public ConsoleEventArgs args;
			}

			private static void Postfix()
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0029: Expected O, but got Unknown
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				object obj = <>c.<>9__0_0;
				if (obj == null)
				{
					ConsoleEvent val = delegate(ConsoleEventArgs args)
					{
						//IL_0067: Unknown result type (might be due to invalid IL or missing references)
						//IL_0071: Invalid comparison between Unknown and I4
						//IL_023a: Unknown result type (might be due to invalid IL or missing references)
						//IL_0244: Invalid comparison between Unknown and I4
						//IL_081e: Unknown result type (might be due to invalid IL or missing references)
						<>c__DisplayClass0_0 CS$<>8__locals0 = new <>c__DisplayClass0_0();
						CS$<>8__locals0.args = args;
						if (!ServerCharacters.configSync.IsAdmin)
						{
							CS$<>8__locals0.args.Context.AddString("You are not an admin on this server.");
						}
						else if (CS$<>8__locals0.args.Length >= 3 && CS$<>8__locals0.args[1] == "resetskill")
						{
							if ((int)GetSkillType(CS$<>8__locals0.args[2]) == 999)
							{
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[2] + " is not a valid skill.");
							}
							else if (CS$<>8__locals0.args.Length > 3)
							{
								string text = CS$<>8__locals0.args[3];
								int num = 4;
								if (text.StartsWith("\"", StringComparison.Ordinal))
								{
									text = text.Substring(1);
									while (num < CS$<>8__locals0.args.Length && !text.EndsWith("\"", StringComparison.Ordinal))
									{
										text = text + " " + CS$<>8__locals0.args[num++];
									}
									text = text.Substring(0, text.Length - 1);
								}
								ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters ResetSkill", new object[3]
								{
									CS$<>8__locals0.args[2],
									text,
									(CS$<>8__locals0.args.Length > num) ? CS$<>8__locals0.args[num] : "0"
								});
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[2] + " has been reset for " + text + ".");
							}
							else
							{
								ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters ResetSkill", new object[3]
								{
									CS$<>8__locals0.args[2],
									"",
									"0"
								});
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[2] + " has been reset for everyone.");
							}
						}
						else if (CS$<>8__locals0.args.Length >= 3 && CS$<>8__locals0.args[1] == "raiseskill")
						{
							if ((int)GetSkillType(CS$<>8__locals0.args[2]) == 999)
							{
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[2] + " is not a valid skill.");
							}
							else if (CS$<>8__locals0.args.Length > 4)
							{
								string text2 = CS$<>8__locals0.args[4];
								int num2 = 5;
								if (text2.StartsWith("\"", StringComparison.Ordinal))
								{
									text2 = text2.Substring(1);
									while (num2 < CS$<>8__locals0.args.Length && !text2.EndsWith("\"", StringComparison.Ordinal))
									{
										text2 = text2 + " " + CS$<>8__locals0.args[num2++];
									}
									text2 = text2.Substring(0, text2.Length - 1);
								}
								ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters RaiseSkill", new object[4]
								{
									CS$<>8__locals0.args[2],
									int.Parse(CS$<>8__locals0.args[3]),
									text2,
									(CS$<>8__locals0.args.Length > num2) ? CS$<>8__locals0.args[num2] : "0"
								});
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[2] + " has been raised by " + CS$<>8__locals0.args[3] + " for " + text2 + ".");
							}
							else
							{
								ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters RaiseSkill", new object[4]
								{
									CS$<>8__locals0.args[2],
									int.Parse(CS$<>8__locals0.args[3]),
									"",
									"0"
								});
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[2] + " has been raised by " + CS$<>8__locals0.args[3] + " for everyone.");
							}
						}
						else if (CS$<>8__locals0.args.Length >= 3 && CS$<>8__locals0.args[1] == "giveitem")
						{
							if (ObjectDB.instance.GetItemPrefab(CS$<>8__locals0.args[2]) == null)
							{
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[2] + " is not a valid item.");
							}
							else if (CS$<>8__locals0.args.Length > 4)
							{
								string text3 = CS$<>8__locals0.args[4];
								int num3 = 5;
								if (text3.StartsWith("\"", StringComparison.Ordinal))
								{
									text3 = text3.Substring(1);
									while (num3 < CS$<>8__locals0.args.Length && !text3.EndsWith("\"", StringComparison.Ordinal))
									{
										text3 = text3 + " " + CS$<>8__locals0.args[num3++];
									}
									text3 = text3.Substring(0, text3.Length - 1);
								}
								ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters GiveItem", new object[4]
								{
									CS$<>8__locals0.args[2],
									int.Parse(CS$<>8__locals0.args[3]),
									text3,
									(CS$<>8__locals0.args.Length > num3) ? CS$<>8__locals0.args[num3] : "0"
								});
								CS$<>8__locals0.args.Context.AddString(CS$<>8__locals0.args[3] + "x " + CS$<>8__locals0.args[2] + " has been given to " + text3 + ", if their inventory isn't full.");
							}
							else
							{
								CS$<>8__locals0.args.Context.AddString("Please specify a target player.");
							}
						}
						else if (CS$<>8__locals0.args.Length >= 3 && CS$<>8__locals0.args[1] == "teleport")
						{
							string text4 = CS$<>8__locals0.args[2];
							int num4 = 3;
							if (text4.StartsWith("\"", StringComparison.Ordinal))
							{
								text4 = text4.Substring(1);
								while (num4 < CS$<>8__locals0.args.Length && !text4.EndsWith("\"", StringComparison.Ordinal))
								{
									text4 = text4 + " " + CS$<>8__locals0.args[num4++];
								}
								text4 = text4.Substring(0, text4.Length - 1);
							}
							ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters GetPlayerPos", new object[2]
							{
								text4,
								(CS$<>8__locals0.args.Length > num4) ? CS$<>8__locals0.args[num4] : "0"
							});
							((MonoBehaviour)ServerCharacters.selfReference).StartCoroutine(AwaitResponse());
						}
						else if (CS$<>8__locals0.args.Length >= 3 && CS$<>8__locals0.args[1] == "summon")
						{
							string text5 = CS$<>8__locals0.args[2];
							int num5 = 3;
							if (text5.StartsWith("\"", StringComparison.Ordinal))
							{
								text5 = text5.Substring(1);
								while (num5 < CS$<>8__locals0.args.Length && !text5.EndsWith("\"", StringComparison.Ordinal))
								{
									text5 = text5 + " " + CS$<>8__locals0.args[num5++];
								}
								text5 = text5.Substring(0, text5.Length - 1);
							}
							ZNet.instance.GetServerPeer().m_rpc.Invoke("ServerCharacters SendOwnPos", new object[3]
							{
								text5,
								(CS$<>8__locals0.args.Length > num5) ? CS$<>8__locals0.args[num5] : "0",
								((Component)Player.m_localPlayer).transform.position
							});
							((MonoBehaviour)ServerCharacters.selfReference).StartCoroutine(AwaitResponse());
						}
						else
						{
							CS$<>8__locals0.args.Context.AddString("ServerCharacters console commands - use 'ServerCharacters' followed by one of the following options.");
							CS$<>8__locals0.args.Context.AddString("resetskill [skillname] [playername] [id] - resets the skill for the specified player. Steam / Xbox ID is optional and only required, if multiple players have the same name. If no name is provided, the skill is reset for every character on the server, online and offline.");
							CS$<>8__locals0.args.Context.AddString("raiseskill [skillname] [level] [playername] [id] - raises the skill for the specified player by the specified level. Steam / Xbox ID is optional and only required, if multiple players have the same name. If no name is provided, the skill is raised for every character on the server, online and offline.");
							CS$<>8__locals0.args.Context.AddString("teleport [playername] [steamid] - teleports you to the specified player. Quote names with a space. Steam / Xbox ID is optional and only required, if multiple players have the same name.");
							CS$<>8__locals0.args.Context.AddString("summon [playername] [steamid] - teleports the specified player to you. Quote names with a space. Steam / Xbox ID is optional and only required, if multiple players have the same name.");
							CS$<>8__locals0.args.Context.AddString("giveitem [itemname] [quantity] [playername] [id] - adds the specified item to the specified players inventory in the specified quantity. Quote names with a space. Steam / Xbox ID is optional and only required, if multiple players have the same name. Will fail, if their inventory is full.");
						}
						[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
						[IteratorStateMachine(typeof(<>c__DisplayClass0_0.<<Postfix>g__AwaitResponse|5>d))]
						IEnumerator AwaitResponse()
						{
							//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
							return new <>c__DisplayClass0_0.<<Postfix>g__AwaitResponse|5>d(0)
							{
								<>4__this = CS$<>8__locals0
							};
						}
						[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
						[IteratorStateMachine(typeof(<>c__DisplayClass0_0.<<Postfix>g__AwaitResponse|7>d))]
						IEnumerator AwaitResponse()
						{
							//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
							return new <>c__DisplayClass0_0.<<Postfix>g__AwaitResponse|7>d(0)
							{
								<>4__this = CS$<>8__locals0
							};
						}
					};
					<>c.<>9__0_0 = val;
					obj = (object)val;
				}
				object obj2 = <>c.<>9__0_1;
				if (obj2 == null)
				{
					ConsoleOptionsFetcher val2 = () => new List<string> { "resetskill", "teleport", "summon", "raiseskill", "giveitem" };
					<>c.<>9__0_1 = val2;
					obj2 = (object)val2;
				}
				new ConsoleCommand("ServerCharacters", "Manages the ServerCharacters commands.", (ConsoleEvent)obj, false, false, false, false, false, (ConsoleOptionsFetcher)obj2, false, false, false);
				[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
				static SkillType GetSkillType(string name)
				{
					//IL_005a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0085: Unknown result type (might be due to invalid IL or missing references)
					Dictionary<SkillType, Skill> skillData = ((Character)Player.m_localPlayer).GetSkills().m_skillData;
					Dictionary<SkillType, Skill> src = ((IEnumerable<KeyValuePair<SkillType, Skill>>)skillData).ToDictionary((Func<KeyValuePair<SkillType, Skill>, SkillType>)((KeyValuePair<SkillType, Skill> kv) => kv.Key), (Func<KeyValuePair<SkillType, Skill>, Skill>)((KeyValuePair<SkillType, Skill> kv) => new Skill(kv.Value.m_info)
					{
						m_accumulator = kv.Value.m_accumulator,
						m_level = kv.Value.m_level
					}));
					SaveLastSkillReset.last = (SkillType)999;
					try
					{
						SilenceConsole.silence = true;
						((Character)Player.m_localPlayer).GetSkills().CheatResetSkill(name);
					}
					finally
					{
						SilenceConsole.silence = false;
					}
					Utils.OverwriteDict(src, skillData);
					return SaveLastSkillReset.last;
				}
			}

			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			[CompilerGenerated]
			internal static SkillType <Postfix>g__GetSkillType|0_2(string name)
			{
				//IL_005a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0085: Unknown result type (might be due to invalid IL or missing references)
				Dictionary<SkillType, Skill> skillData = ((Character)Player.m_localPlayer).GetSkills().m_skillData;
				Dictionary<SkillType, Skill> src = ((IEnumerable<KeyValuePair<SkillType, Skill>>)skillData).ToDictionary((Func<KeyValuePair<SkillType, Skill>, SkillType>)((KeyValuePair<SkillType, Skill> kv) => kv.Key), (Func<KeyValuePair<SkillType, Skill>, Skill>)((KeyValuePair<SkillType, Skill> kv) => new Skill(kv.Value.m_info)
				{
					m_accumulator = kv.Value.m_accumulator,
					m_level = kv.Value.m_level
				}));
				SaveLastSkillReset.last = (SkillType)999;
				try
				{
					SilenceConsole.silence = true;
					((Character)Player.m_localPlayer).GetSkills().CheatResetSkill(name);
				}
				finally
				{
					SilenceConsole.silence = false;
				}
				Utils.OverwriteDict(src, skillData);
				return SaveLastSkillReset.last;
			}
		}

		[HarmonyPatch(typeof(PlayerProfile), "SavePlayerData")]
		private static class PatchPlayerProfilePlayerSave
		{
			[UsedImplicitly]
			private static void Prefix()
			{
				if (serverCharacter && doEmergencyBackup && playerSnapShotLast != null)
				{
					Player localPlayer = Player.m_localPlayer;
					if (localPlayer != null)
					{
						((Humanoid)localPlayer).m_inventory.m_inventory = playerSnapShotLast.inventory;
						Utils.OverwriteDict(playerSnapShotLast.knownStations, localPlayer.m_knownStations);
						Utils.OverwriteDict(playerSnapShotLast.knownTexts, localPlayer.m_knownTexts);
					}
				}
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[HarmonyPatch(typeof(PlayerProfile), "SavePlayerToDisk")]
		private static class PatchPlayerProfileSave_Client
		{
			[CompilerGenerated]
			private sealed class <>c__DisplayClass0_0
			{
				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public byte[] packageArray;
			}

			private static readonly MethodInfo ArrayWriter = AccessTools.DeclaredMethod(typeof(BinaryWriter), "Write", new Type[1] { typeof(byte[]) }, (Type[])null);

			private static readonly MethodInfo ServerCharacterSaver = AccessTools.DeclaredMethod(typeof(PatchPlayerProfileSave_Client), "SaveCharacterToServer", (Type[])null, (Type[])null);

			private static byte[] SaveCharacterToServer(byte[] packageArray, PlayerProfile profile)
			{
				<>c__DisplayClass0_0 CS$<>8__locals0 = new <>c__DisplayClass0_0();
				CS$<>8__locals0.packageArray = packageArray;
				if (serverCharacter && doEmergencyBackup && serverEncryptionKey != null)
				{
					string characterSavePath = Utils.CharacterSavePath;
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					File.WriteAllBytes(characterSavePath + directorySeparatorChar + profile.m_filename + ".fch.signature", generateProfileSignature(CS$<>8__locals0.packageArray, serverEncryptionKey));
					string characterSavePath2 = Utils.CharacterSavePath;
					directorySeparatorChar = Path.DirectorySeparatorChar;
					File.WriteAllBytes(characterSavePath2 + directorySeparatorChar + profile.m_filename + ".fch.serverbackup", CS$<>8__locals0.packageArray);
					doEmergencyBackup = false;
				}
				if (serverCharacter && !currentlySaving)
				{
					ZNet instance = ZNet.instance;
					if (instance != null)
					{
						ZNetPeer serverPeer = instance.GetServerPeer();
						if (((serverPeer != null) ? new bool?(serverPeer.IsReady()) : null).GetValueOrDefault())
						{
							if (forceSynchronousSaving)
							{
								foreach (bool item in Shared.sendCompressedDataToPeer(ZNet.instance.GetServerPeer(), (iDied && ServerCharacters.hardcoreMode.GetToggle()) ? "ServerCharacters PlayerDied" : "ServerCharacters PlayerProfile", CS$<>8__locals0.packageArray))
								{
									if (!item)
									{
										Thread.Sleep(10);
									}
								}
							}
							else
							{
								currentlySaving = true;
								((MonoBehaviour)ZNet.instance).StartCoroutine(saveAsync());
							}
							return CS$<>8__locals0.packageArray;
						}
					}
				}
				return CS$<>8__locals0.packageArray;
				[IteratorStateMachine(typeof(<>c__DisplayClass0_0.<<SaveCharacterToServer>g__saveAsync|0>d))]
				IEnumerator saveAsync()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass0_0.<<SaveCharacterToServer>g__saveAsync|0>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}

			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(MethodBase method, IEnumerable<CodeInstruction> instructions)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0025: Expected O, but got Unknown
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Expected O, but got Unknown
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0051: Expected O, but got Unknown
				return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch(new CodeInstruction(OpCodes.Callvirt, (object)ArrayWriter), (string)null)
				}).Insert((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Call, (object)ServerCharacterSaver)
				}).Instructions();
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[HarmonyPatch]
		private class EnableSocketLinger
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__4 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private IEnumerable<CodeInstruction> codeInstructions;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				public IEnumerable<CodeInstruction> <>3__codeInstructions;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private IEnumerator<CodeInstruction> <>7__wrap1;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				private CodeInstruction <instruction>5__3;

				CodeInstruction IEnumerator<CodeInstruction>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <Transpiler>d__4(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || (uint)(num - 1) <= 2u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<>7__wrap1 = null;
					<instruction>5__3 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b8: Expected O, but got Unknown
					//IL_008a: Unknown result type (might be due to invalid IL or missing references)
					//IL_0094: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<>7__wrap1 = codeInstructions.GetEnumerator();
							<>1__state = -3;
							goto IL_00f1;
						case 1:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Ldc_I4_1, (object)null);
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -3;
							goto IL_00cb;
						case 3:
							{
								<>1__state = -3;
								<instruction>5__3 = null;
								goto IL_00f1;
							}
							IL_00f1:
							if (<>7__wrap1.MoveNext())
							{
								<instruction>5__3 = <>7__wrap1.Current;
								if (<instruction>5__3.opcode == OpCodes.Call && CodeInstructionExtensions.OperandIs(<instruction>5__3, (MemberInfo)socketClose))
								{
									<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
									<>1__state = 1;
									return true;
								}
								goto IL_00cb;
							}
							<>m__Finally1();
							<>7__wrap1 = null;
							return false;
							IL_00cb:
							<>2__current = <instruction>5__3;
							<>1__state = 3;
							return true;
						}
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>7__wrap1 != null)
					{
						<>7__wrap1.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}

				[DebuggerHidden]
				[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__4 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__4(0);
					}
					<Transpiler>d__.codeInstructions = <>3__codeInstructions;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			private static MethodInfo socketClose => AccessTools.Method(typeof(SteamNetworkingSockets), "CloseConnection", (Type[])null, (Type[])null);

			private static void dummy()
			{
			}

			private static MethodInfo TargetMethod()
			{
				Type type = Type.GetType("ZSteamSocket, assembly_valheim");
				if ((object)type == null)
				{
					return AccessTools.DeclaredMethod(typeof(EnableSocketLinger), "dummy", (Type[])null, (Type[])null);
				}
				return AccessTools.DeclaredMethod(type, "Close", (Type[])null, (Type[])null);
			}

			[IteratorStateMachine(typeof(<Transpiler>d__4))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> codeInstructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__4(-2)
				{
					<>3__codeInstructions = codeInstructions
				};
			}
		}

		[HarmonyPatch(typeof(Game), "Shutdown")]
		private static class PatchGameShutdown
		{
			[UsedImplicitly]
			private static void Prefix()
			{
				forceSynchronousSaving = true;
			}

			[UsedImplicitly]
			private static void Finalizer()
			{
				serverCharacter = false;
				forceSynchronousSaving = false;
			}
		}

		[HarmonyPatch(typeof(Player), "Save")]
		private static class StorePoisonDebuff
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Prefix(Player __instance)
			{
				if (ServerCharacters.storePoison.GetToggle())
				{
					StatusEffect statusEffect = ((Character)__instance).m_seman.GetStatusEffect(StringExtensionMethods.GetStableHashCode("Poison"));
					SE_Poison val = (SE_Poison)(object)((statusEffect is SE_Poison) ? statusEffect : null);
					if (val != null && !((Character)__instance).IsDead())
					{
						__instance.m_customData["ServerCharacters PoisonDamage"] = val.m_damageLeft.ToString(CultureInfo.InvariantCulture);
						__instance.m_customData["ServerCharacters PoisonDamageHit"] = val.m_damagePerHit.ToString(CultureInfo.InvariantCulture);
						__instance.m_customData["ServerCharacters PoisonTTL"] = ((StatusEffect)val).m_ttl.ToString(CultureInfo.InvariantCulture);
					}
					else
					{
						__instance.m_customData.Remove("ServerCharacters PoisonDamage");
						__instance.m_customData.Remove("ServerCharacters PoisonDamageHit");
						__instance.m_customData.Remove("ServerCharacters PoisonTTL");
					}
				}
			}
		}

		[HarmonyPatch(typeof(Player), "Load")]
		private static class LoadPoisonDebuff
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Postfix(Player __instance)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_0067: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				if (((Character)__instance).m_nview.m_zdo != null && ServerCharacters.storePoison.GetToggle() && __instance.m_customData.TryGetValue("ServerCharacters PoisonDamage", out var value) && value != "")
				{
					SE_Poison val = (SE_Poison)((Character)__instance).m_seman.AddStatusEffect(StringExtensionMethods.GetStableHashCode("Poison"), false, 0, 0f);
					val.m_damageLeft = float.Parse(__instance.m_customData["ServerCharacters PoisonDamage"], CultureInfo.InvariantCulture);
					val.m_damagePerHit = float.Parse(__instance.m_customData["ServerCharacters PoisonDamageHit"], CultureInfo.InvariantCulture);
					((StatusEffect)val).m_ttl = float.Parse(__instance.m_customData["ServerCharacters PoisonTTL"], CultureInfo.InvariantCulture);
				}
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		private static class PatchZNetOnNewConnection
		{
			[UsedImplicitly]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c3: Expected O, but got Unknown
				if (ZNet.instance.IsServer())
				{
					return;
				}
				peer.m_rpc.Register<ZPackage>("ServerCharacters PlayerProfile", Shared.receiveCompressedFromPeer(onReceivedProfile));
				peer.m_rpc.Register<ZPackage>("ServerCharacters KeyExchange", (Action<ZRpc, ZPackage>)receiveEncryptionKeyFromServer);
				peer.m_rpc.Register<string>("ServerCharacters IngameMessage", (Action<ZRpc, string>)onReceivedIngameMessage);
				peer.m_rpc.Register<string>("ServerCharacters KickMessage", (Action<ZRpc, string>)onReceivedKickMessage);
				peer.m_rpc.Register<string>("ServerCharacters ResetSkill", (Action<ZRpc, string>)onReceivedResetSkill);
				peer.m_rpc.Register<string, int>("ServerCharacters RaiseSkill", (Action<ZRpc, string, int>)onReceivedRaiseSkill);
				peer.m_rpc.Register<Vector3>("ServerCharacters GetPlayerPos", (Action<ZRpc, Vector3>)onReceivedPlayerPos);
				peer.m_rpc.Register<string, int>("ServerCharacters GiveItem", (Action<ZRpc, string, int>)onReceivedGiveItem);
				peer.m_rpc.Register<Vector3>("ServerCharacters SendOwnPos", (Action<ZRpc, Vector3>)onReceivedOwnPos);
				peer.m_rpc.Register<Vector3>("ServerCharacters TeleportTo", (Action<ZRpc, Vector3>)onReceivedTeleportTo);
				string characterSavePath = Utils.CharacterSavePath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				string path = characterSavePath + directorySeparatorChar + Game.instance.m_playerProfile.m_filename + ".fch.signature";
				string characterSavePath2 = Utils.CharacterSavePath;
				directorySeparatorChar = Path.DirectorySeparatorChar;
				string path2 = characterSavePath2 + directorySeparatorChar + Game.instance.m_playerProfile.m_filename + ".fch.serverbackup";
				if (!File.Exists(path) || !File.Exists(path2))
				{
					return;
				}
				Utils.Log("Found emergency backup and signature for character '" + Game.instance.m_playerProfile.m_filename + "'. Trying to restore the backup.");
				ZPackage val = new ZPackage();
				val.Write(File.ReadAllBytes(path2));
				val.Write(File.ReadAllBytes(path));
				foreach (bool item in Shared.sendCompressedDataToPeer(peer, "ServerCharacters CheckSignature", val.GetArray()))
				{
					if (!item)
					{
						Thread.Sleep(10);
					}
				}
			}

			private static void onReceivedOwnPos(ZRpc peerRpc, Vector3 pos)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				if (awaitingPos != null)
				{
					awaitingPos.SetResult(pos);
					awaitingPos = null;
				}
			}

			private static void onReceivedTeleportTo(ZRpc peerRpc, Vector3 pos)
			{
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				((Character)Player.m_localPlayer).TeleportTo(pos, Quaternion.identity, true);
			}

			private static void onReceivedPlayerPos(ZRpc peerRpc, Vector3 pos)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				if (awaitingPos != null)
				{
					awaitingPos.SetResult(pos);
					awaitingPos = null;
				}
			}

			private static void onReceivedGiveItem(ZRpc peerRpc, string itemName, int itemQuantity)
			{
				string text = (((Humanoid)Player.m_localPlayer).m_inventory.AddItem(ObjectDB.instance.GetItemPrefab(itemName), itemQuantity) ? $"An admin added {itemQuantity}x {itemName} to your inventory." : $"An admin tried to add {itemQuantity}x {itemName} to your inventory, but it is full.");
				((Terminal)Chat.instance).AddString(text);
				Chat.instance.m_hideTimer = 0f;
				MessageHud.instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false);
			}

			private static void onReceivedResetSkill(ZRpc peerRpc, string skill)
			{
				Player.m_localPlayer.m_skills.CheatResetSkill(skill);
				string text = "An admin reset your skill " + skill;
				((Terminal)Chat.instance).AddString(text);
				Chat.instance.m_hideTimer = 0f;
				MessageHud.instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false);
			}

			private static void onReceivedRaiseSkill(ZRpc peerRpc, string skill, int level)
			{
				Player.m_localPlayer.m_skills.CheatRaiseSkill(skill, (float)level, true);
				string text = $"An admin raised your skill {skill} by {level}";
				((Terminal)Chat.instance).AddString(text);
				Chat.instance.m_hideTimer = 0f;
				MessageHud.instance.ShowMessage((MessageType)2, text, 0, (Sprite)null, false);
			}

			private static void onReceivedIngameMessage(ZRpc peerRpc, string message)
			{
				((Terminal)Chat.instance).AddString(message);
				Chat.instance.m_hideTimer = 0f;
				MessageHud.instance.ShowMessage((MessageType)2, message, 0, (Sprite)null, false);
			}

			private static void onReceivedKickMessage(ZRpc peerRpc, string message)
			{
				connectionError = message;
			}

			private static void onReceivedProfile(ZRpc peerRpc, byte[] profileData)
			{
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_005a: Expected O, but got Unknown
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				if (profileData.Length == 0)
				{
					if (Game.instance.m_playerProfile.m_worldData.Count != 0)
					{
						Game.instance.Logout(true, true);
						ZNet.m_connectionStatus = (ConnectionStatus)5;
						connectionError = "Please create a new character, before connecting to this server, to avoid loss of data.";
					}
					else
					{
						serverCharacter = true;
						acquireCharacterFromTemplate = true;
					}
					return;
				}
				PlayerProfile val = new PlayerProfile(Game.instance.m_playerProfile.m_filename, (FileSource)0);
				if (!val.LoadPlayerProfileFromBytes(profileData) || Shared.CharacterNameIsForbidden(val.m_playerName))
				{
					Game.instance.Logout(true, true);
					ZNet.m_connectionStatus = (ConnectionStatus)5;
					connectionError = "The saved data on the server was corrupt, please contact your server admin or create a new character.";
				}
				else
				{
					serverCharacter = true;
					Game.instance.m_playerProfile = val;
					cleanEmergencyBackup();
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class DetectBackupOnlyMode
		{
			[UsedImplicitly]
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Postfix(ZNet __instance)
			{
				if (ServerCharacters.backupOnlyMode.GetToggle() && !__instance.IsServer())
				{
					serverCharacter = true;
				}
			}
		}

		[HarmonyPatch(typeof(Game), "SpawnPlayer")]
		private class InitializePlayerFromTemplate
		{
			[UsedImplicitly]
			private static void Postfix()
			{
				//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_0232: Unknown result type (might be due to invalid IL or missing references)
				if (ServerCharacters.backupOnlyMode.GetToggle())
				{
					cleanEmergencyBackup();
				}
				bool num;
				if (!ServerCharacters.backupOnlyMode.GetToggle())
				{
					num = !acquireCharacterFromTemplate;
				}
				else
				{
					if (Game.instance.GetPlayerProfile().HaveLogoutPoint())
					{
						return;
					}
					num = Game.instance.GetPlayerProfile().HaveCustomSpawnPoint();
				}
				if (num)
				{
					return;
				}
				acquireCharacterFromTemplate = false;
				((Humanoid)Player.m_localPlayer).m_inventory.RemoveAll();
				Player.m_localPlayer.m_skills.m_skillData.Clear();
				Player.m_localPlayer.m_knownMaterial.Clear();
				Player.m_localPlayer.m_knownRecipes.Clear();
				Player.m_localPlayer.m_knownStations.Clear();
				Player.m_localPlayer.m_knownTexts.Clear();
				Player.m_localPlayer.m_uniques.Clear();
				Player.m_localPlayer.m_trophies.Clear();
				Player.m_localPlayer.m_customData.Clear();
				((Humanoid)Player.m_localPlayer).GiveDefaultItems();
				try
				{
					PlayerTemplate playerTemplate = new DeserializerBuilder().IgnoreFields().Build().Deserialize<PlayerTemplate>(ServerCharacters.playerTemplate.Value);
					if (playerTemplate != null)
					{
						foreach (KeyValuePair<string, float> skill in playerTemplate.skills)
						{
							((Character)Player.m_localPlayer).GetSkills().CheatRaiseSkill(skill.Key, skill.Value, true);
						}
						Inventory inventory = ((Humanoid)Player.m_localPlayer).m_inventory;
						foreach (KeyValuePair<string, int> item in playerTemplate.items)
						{
							inventory.AddItem(item.Key, item.Value, 1, 0, 0L, "", false);
						}
						List<PlayerTemplate.Position> spawn = playerTemplate.spawn;
						if (spawn != null && spawn.Count > 0)
						{
							State state = Random.state;
							Random.InitState(((object)(PlatformUserID)(ref UserInfo.GetLocalUser().UserId)).GetHashCode());
							int index = Random.Range(0, spawn.Count - 1);
							Random.state = state;
							((Component)Player.m_localPlayer).transform.position = new Vector3((float)spawn[index].x, (float)spawn[index].y, (float)spawn[index].z);
						}
					}
				}
				catch (SerializationException)
				{
				}
				Game.instance.SavePlayerProfile(true);
				if (!(ServerCharacters.firstLoginMessage.Value != ""))
				{
					return;
				}
				foreach (Player allPlayer in Player.GetAllPlayers())
				{
					((Character)allPlayer).Message((MessageType)2, ServerCharacters.firstLoginMessage.Value.Replace("{name}", ((Character)Player.m_localPlayer).GetHoverName()), 0, (Sprite)null);
				}
			}
		}

		[HarmonyPatch(typeof(Valkyrie), "Awake")]
		private class ChangeValkyrieTarget
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Prefix(Valkyrie __instance)
			{
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				if (!((Component)__instance).GetComponent<ZNetView>().IsOwner())
				{
					return;
				}
				try
				{
					PlayerTemplate playerTemplate = new DeserializerBuilder().IgnoreFields().Build().Deserialize<PlayerTemplate>(ServerCharacters.playerTemplate.Value);
					if (playerTemplate != null)
					{
						List<PlayerTemplate.Position> spawn = playerTemplate.spawn;
						if (spawn != null && spawn.Count > 0)
						{
							State state = Random.state;
							Random.InitState(((object)(PlatformUserID)(ref UserInfo.GetLocalUser().UserId)).GetHashCode());
							int index = Random.Range(0, spawn.Count - 1);
							Random.state = state;
							((Component)Player.m_localPlayer).transform.position = new Vector3((float)spawn[index].x, (float)spawn[index].y, (float)spawn[index].z);
						}
					}
				}
				catch (SerializationException)
				{
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnSpawned")]
		private static class DisableValkyrieAndIntro
		{
			private static void Postfix(bool spawnValkyrie)
			{
				if (spawnValkyrie)
				{
					switch (ServerCharacters.newCharacterIntro.Value)
					{
					case Intro.Disabled:
						Game.instance.SkipIntro();
						break;
					case Intro.Valkyrie:
						Game.instance.m_inIntro = (Game.instance.m_queuedIntro = false);
						TextViewer.instance.HideIntro();
						break;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Game), "FindSpawnPoint")]
		private class ReplaceSpawnPoint
		{
			private static bool CheckCustomSpawnPoint(out Vector3 pos)
			{
				//IL_0023: Unknown result type (might be due to invalid IL or missing references)
				//IL_0028: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					PlayerTemplate playerTemplate = new DeserializerBuilder().IgnoreFields().Build().Deserialize<PlayerTemplate>(ServerCharacters.playerTemplate.Value);
					if (playerTemplate == null)
					{
						pos = Vector3.zero;
						return false;
					}
					List<PlayerTemplate.Position> spawn = playerTemplate.spawn;
					if (spawn != null && spawn.Count > 0)
					{
						State state = Random.state;
						Random.InitState(((object)(PlatformUserID)(ref UserInfo.GetLocalUser().UserId)).GetHashCode());
						int index = Random.Range(0, spawn.Count - 1);
						Random.state = state;
						pos = new Vector3((float)spawn[index].x, (float)spawn[index].y, (float)spawn[index].z);
						return true;
					}
				}
				catch (SerializationException)
				{
				}
				pos = Vector3.zero;
				return false;
			}

			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> _instructions, ILGenerator ilg)
			{
				//IL_015b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0160: Unknown result type (might be due to invalid IL or missing references)
				//IL_016e: Expected O, but got Unknown
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Expected O, but got Unknown
				//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b1: Expected O, but got Unknown
				MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZoneSystem), "GetLocationIcon", (Type[])null, (Type[])null);
				FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(Game), "m_StartLocation");
				List<CodeInstruction> list = _instructions.ToList();
				for (int i = 0; i < list.Count; i++)
				{
					if (i < list.Count - 4 && list[i].opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(list[i], (MemberInfo)methodInfo) && list[i - 2].opcode == OpCodes.Ldfld && CodeInstructionExtensions.OperandIs(list[i - 2], (MemberInfo)fieldInfo))
					{
						int num = i;
						MethodInfo methodInfo2 = AccessTools.DeclaredPropertyGetter(typeof(ZoneSystem), "instance");
						while (list[num].opcode != OpCodes.Call || !CodeInstructionExtensions.OperandIs(list[num], (MemberInfo)methodInfo2))
						{
							num--;
						}
						CodeInstruction obj = list.Skip(i).SkipWhile((CodeInstruction instr) => instr.opcode.FlowControl != FlowControl.Cond_Branch).Skip(1)
							.First();
						Label label = ilg.DefineLabel();
						obj.labels.Add(label);
						List<Label> labels = list[num].labels;
						list.InsertRange(num, (IEnumerable<CodeInstruction>)(object)new CodeInstruction[4]
						{
							new CodeInstruction(OpCodes.Nop, (object)null)
							{
								labels = new List<Label>(labels)
							},
							list[i - 1],
							new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ReplaceSpawnPoint), "CheckCustomSpawnPoint", (Type[])null, (Type[])null)),
							new CodeInstruction(OpCodes.Brtrue, (object)label)
						});
						labels.Clear();
						break;
					}
				}
				return list;
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[HarmonyPatch(typeof(Player), "CreateTombStone")]
		private class PreserveItemsOnHardcoreModeDeath
		{
			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
			private static ZPackage playerSave;

			[HarmonyPriority(700)]
			private static void Prefix(Player __instance)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Expected O, but got Unknown
				if (ServerCharacters.hardcoreMode.GetToggle() && iDied)
				{
					playerSave = new ZPackage();
					__instance.Save(playerSave);
					playerSave.SetPos(0);
				}
			}

			[HarmonyPriority(100)]
			private static void Postfix(Player __instance)
			{
				if (playerSave != null && ServerCharacters.hardcoreMode.GetToggle() && iDied)
				{
					__instance.m_knownTexts.Clear();
					__instance.m_knownStations.Clear();
					__instance.Load(playerSave);
					playerSave = null;
				}
			}
		}

		[HarmonyPatch(typeof(Game), "UpdateRespawn")]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		private static class ChangeSpawnShoutMessage
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__1 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private IEnumerable<CodeInstruction> instructions;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				public IEnumerable<CodeInstruction> <>3__instructions;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				private ILGenerator ilg;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public ILGenerator <>3__ilg;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				private MethodInfo <sendText>5__2;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private IEnumerator<CodeInstruction> <>7__wrap2;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				private CodeInstruction <instruction>5__4;

				private Label <skipLabel>5__5;

				private Label <endLabel>5__6;

				CodeInstruction IEnumerator<CodeInstruction>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <Transpiler>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || (uint)(num - 1) <= 11u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<sendText>5__2 = null;
					<>7__wrap2 = null;
					<instruction>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0115: Unknown result type (might be due to invalid IL or missing references)
					//IL_011f: Expected O, but got Unknown
					//IL_0140: Unknown result type (might be due to invalid IL or missing references)
					//IL_014a: Expected O, but got Unknown
					//IL_019b: Unknown result type (might be due to invalid IL or missing references)
					//IL_01a5: Expected O, but got Unknown
					//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
					//IL_01d6: Expected O, but got Unknown
					//IL_021f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0229: Expected O, but got Unknown
					//IL_0246: Unknown result type (might be due to invalid IL or missing references)
					//IL_024b: Unknown result type (might be due to invalid IL or missing references)
					//IL_0267: Expected O, but got Unknown
					//IL_0284: Unknown result type (might be due to invalid IL or missing references)
					//IL_028e: Expected O, but got Unknown
					//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
					//IL_02b6: Expected O, but got Unknown
					//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
					//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
					//IL_02f5: Expected O, but got Unknown
					//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
					//IL_00f8: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<sendText>5__2 = AccessTools.DeclaredMethod(typeof(Chat), "SendText", (Type[])null, (Type[])null);
							<>7__wrap2 = instructions.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Dup, (object)null);
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Ldstr, (object)"");
							<>1__state = 3;
							return true;
						case 3:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(string), "Equals", new Type[2]
							{
								typeof(string),
								typeof(string)
							}, (Type[])null));
							<>1__state = 4;
							return true;
						case 4:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Brtrue, (object)<skipLabel>5__5);
							<>1__state = 5;
							return true;
						case 5:
							<>1__state = -3;
							<>2__current = <instruction>5__4;
							<>1__state = 6;
							return true;
						case 6:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Br, (object)<endLabel>5__6);
							<>1__state = 7;
							return true;
						case 7:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Pop, (object)null)
							{
								labels = new List<Label> { <skipLabel>5__5 }
							};
							<>1__state = 8;
							return true;
						case 8:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
							<>1__state = 9;
							return true;
						case 9:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
							<>1__state = 10;
							return true;
						case 10:
							<>1__state = -3;
							<>2__current = new CodeInstruction(OpCodes.Nop, (object)null)
							{
								labels = new List<Label> { <endLabel>5__6 }
							};
							<>1__state = 11;
							return true;
						case 11:
							<>1__state = -3;
							goto IL_032b;
						case 12:
							{
								<>1__state = -3;
								goto IL_032b;
							}
							IL_032b:
							<instruction>5__4 = null;
							break;
						}
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							if (CodeInstructionExtensions.Calls(<instruction>5__4, <sendText>5__2))
							{
								<skipLabel>5__5 = ilg.DefineLabel();
								<endLabel>5__6 = ilg.DefineLabel();
								<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(ChangeSpawnShoutMessage), "ReplaceMessage", (Type[])null, (Type[])null));
								<>1__state = 1;
								return true;
							}
							<>2__current = <instruction>5__4;
							<>1__state = 12;
							return true;
						}
						<>m__Finally1();
						<>7__wrap2 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>7__wrap2 != null)
					{
						<>7__wrap2.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}

				[DebuggerHidden]
				[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__1 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__1(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					<Transpiler>d__.ilg = <>3__ilg;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			private static string ReplaceMessage(string original)
			{
				if (!(ServerCharacters.loginMessage.Value == "I have arrived!"))
				{
					return ServerCharacters.loginMessage.Value;
				}
				return original;
			}

			[IteratorStateMachine(typeof(<Transpiler>d__1))]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator ilg)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__1(-2)
				{
					<>3__instructions = instructions,
					<>3__ilg = ilg
				};
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		private class ShowConnectionError
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Postfix(FejdStartup __instance)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_000a: Invalid comparison between Unknown and I4
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0026: Invalid comparison between Unknown and I4
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0042: Invalid comparison between Unknown and I4
				if ((int)ZNet.GetConnectionStatus() == 987345987)
				{
					__instance.m_connectionFailedError.text = "Server is undergoing maintenance. Please try again later.";
				}
				if ((int)ZNet.GetConnectionStatus() == 498209834)
				{
					__instance.m_connectionFailedError.text = "Your character name contains illegal characters. Please choose a different name.";
				}
				if ((int)ZNet.GetConnectionStatus() == 845979243)
				{
					__instance.m_connectionFailedError.text = "You are not allowed to create more than one character on this server.";
				}
				if (__instance.m_connectionFailedPanel.activeSelf && connectionError != null)
				{
					TMP_Text connectionFailedError = __instance.m_connectionFailedError;
					connectionFailedError.text = connectionFailedError.text + "\n" + connectionError;
					connectionError = null;
				}
				if (iDied && ServerCharacters.hardcoreMode.GetToggle())
				{
					__instance.m_connectionFailedError.text = "You died on a hardcore server. You can continue to use your character in singleplayer, but will have to create a new one to connect to the server.";
					__instance.m_connectionFailedPanel.SetActive(true);
					iDied = false;
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_Disconnect")]
		private class PatchZNetRPC_Disconnect
		{
			[UsedImplicitly]
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Prefix(ZNet __instance)
			{
				if (!__instance.IsServer() && serverCharacter)
				{
					forceSynchronousSaving = true;
					Game.instance.SavePlayerProfile(true);
					forceSynchronousSaving = false;
				}
			}
		}

		[HarmonyPatch(typeof(Game), "OnApplicationQuit")]
		private class PatchGameOnApplicationQuit
		{
			[UsedImplicitly]
			private static void Prefix()
			{
				forceSynchronousSaving = true;
			}
		}

		[HarmonyPatch(typeof(Menu), "QuitGame")]
		private static class ForceSaveOnQuit
		{
			private static void Prefix()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Invalid comparison between Unknown and I4
				if ((int)ZNet.m_onlineBackend == 1)
				{
					ZNet.instance.m_haveStoped = false;
					forceSynchronousSaving = false;
					Game.instance.SavePlayerProfile(true);
				}
			}
		}

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		[HarmonyPatch(typeof(Game), "SavePlayerProfile")]
		private class ForceSavingPosition
		{
			private static bool originalValue;

			[UsedImplicitly]
			private static void Prefix(Game __instance, ref bool setLogoutPoint, out bool __state)
			{
				__state = ZNet.instance.m_haveStoped;
				if (__instance.m_shuttingDown)
				{
					ZNet.instance.m_haveStoped = true;
				}
				if (ZNet.m_world == null || __instance.m_playerProfile.HaveLogoutPoint())
				{
					originalValue = true;
					return;
				}
				originalValue = setLogoutPoint;
				setLogoutPoint = true;
			}

			[UsedImplicitly]
			private static void Postfix(Game __instance)
			{
				if (!originalValue)
				{
					__instance.m_playerProfile.ClearLoguoutPoint();
				}
			}

			[UsedImplicitly]
			private static void Finalizer(bool __state)
			{
				ZNet.instance.m_haveStoped = __state;
			}
		}

		[HarmonyPatch(typeof(Game), "Logout")]
		private class PatchGameLogout
		{
			[UsedImplicitly]
			private static void Prefix()
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Invalid comparison between Unknown and I4
				//IL_0008: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Invalid comparison between Unknown and I4
				doEmergencyBackup = (int)ZNet.GetConnectionStatus() != 1 && (int)ZNet.GetConnectionStatus() != 2 && !Game.instance.IsShuttingDown();
				if (doEmergencyBackup)
				{
					Utils.Log("Lost connection to the server. Preparing for emergency backup of profile data.");
				}
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		private class PlayerSnapshot
		{
			public List<ItemData> inventory;

			public Dictionary<string, int> knownStations;

			public Dictionary<string, string> knownTexts;
		}

		[HarmonyPatch(typeof(Inventory), "Changed")]
		private class PatchInventoryChanged
		{
			[CompilerGenerated]
			private sealed class <>c__DisplayClass1_0
			{
				public Inventory __instance;

				public ZNetPeer serverPeer;
			}

			public static bool queuedThisFrame;

			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Prefix(Inventory __instance)
			{
				<>c__DisplayClass1_0 CS$<>8__locals0 = new <>c__DisplayClass1_0();
				CS$<>8__locals0.__instance = __instance;
				if (!queuedThisFrame && CS$<>8__locals0.__instance == ((Humanoid)(Player.m_localPlayer?)).m_inventory)
				{
					CS$<>8__locals0.serverPeer = ZNet.instance.GetServerPeer();
					if (CS$<>8__locals0.serverPeer != null)
					{
						queuedThisFrame = true;
						((MonoBehaviour)ZNet.instance).StartCoroutine(saveAsync());
					}
				}
				[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
				[IteratorStateMachine(typeof(<>c__DisplayClass1_0.<<Prefix>g__saveAsync|0>d))]
				IEnumerator saveAsync()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass1_0.<<Prefix>g__saveAsync|0>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}
		}

		[HarmonyPatch(typeof(Player), "OnDeath")]
		private class KickPlayerOnDeath
		{
			private static void Prefix()
			{
				if (ServerCharacters.hardcoreMode.GetToggle())
				{
					iDied = true;
					((MonoBehaviour)Game.instance).Invoke("Logout", 1f);
				}
			}
		}

		[HarmonyPatch]
		private static class MonitorPlayerActivityCheck
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static IEnumerable<MethodInfo> TargetMethods()
			{
				return new MethodInfo[2]
				{
					AccessTools.DeclaredMethod(typeof(ZInput), "GetButton", (Type[])null, (Type[])null),
					AccessTools.DeclaredMethod(typeof(ZInput), "GetButtonDown", (Type[])null, (Type[])null)
				};
			}

			private static void Postfix(ref bool __result)
			{
				if (__result)
				{
					MonitorPlayerActivity.counter = 0;
				}
			}
		}

		[HarmonyPatch(typeof(Player), "SetLocalPlayer")]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		private static class MonitorPlayerActivity
		{
			[CompilerGenerated]
			private sealed class <MeasureActivity>d__1 : IEnumerator<object>, IDisposable, IEnumerator
			{
				private int <>1__state;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				private object <>2__current;

				object IEnumerator<object>.Current
				{
					[DebuggerHidden]
					[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <MeasureActivity>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0087: Unknown result type (might be due to invalid IL or missing references)
					//IL_0091: Expected O, but got Unknown
					//IL_006c: Unknown result type (might be due to invalid IL or missing references)
					int num = <>1__state;
					if (num != 0)
					{
						if (num != 1)
						{
							return false;
						}
						<>1__state = -1;
					}
					else
					{
						<>1__state = -1;
					}
					if (++counter >= ServerCharacters.afkKickTimer.Value && ServerCharacters.afkKickTimer.Value > 0 && !ZNet.m_isServer && (!ServerCharacters.configSync.IsAdmin || ServerCharacters.excludeAdminsFromAfkCheck.Value == Toggle.Off))
					{
						Game.instance.Logout(true, true);
						ZNet.m_connectionStatus = (ConnectionStatus)4;
						connectionError = "You have been logged out due to inactivity.";
						counter = 0;
					}
					<>2__current = (object)new WaitForSeconds(60f);
					<>1__state = 1;
					return true;
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}
			}

			public static int counter;

			[IteratorStateMachine(typeof(<MeasureActivity>d__1))]
			private static IEnumerator MeasureActivity()
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <MeasureActivity>d__1(0);
			}

			private static void Postfix(Player __instance)
			{
				PatchInventoryChanged.queuedThisFrame = false;
				((MonoBehaviour)__instance).StartCoroutine(MeasureActivity());
			}
		}

		[HarmonyPatch(typeof(Minimap), "Awake")]
		private static class DisplayMaintenanceCountdown
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Postfix(Minimap __instance)
			{
				//IL_0072: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				maintenanceCountdown = ((Component)Object.Instantiate<Transform>(__instance.m_smallRoot.transform.Find("small_biome"), __instance.m_smallRoot.transform)).GetComponent<TextMeshProUGUI>();
				((Object)maintenanceCountdown).name = "ServerCharacters Maintenance Timer";
				((TMP_Text)maintenanceCountdown).text = "";
				((TMP_Text)maintenanceCountdown).alignment = (TextAlignmentOptions)513;
				RectTransform component = ((Component)maintenanceCountdown).GetComponent<RectTransform>();
				component.anchorMin = new Vector2(0f, 1f);
				component.anchorMax = new Vector2(1f, 1f);
				component.pivot = new Vector2(0f, 0.5f);
				component.anchoredPosition = new Vector2(5f, 0f - component.anchoredPosition.y);
			}
		}

		public static bool serverCharacter;

		private static bool currentlySaving;

		private static bool forceSynchronousSaving;

		private static bool acquireCharacterFromTemplate;

		private static bool doEmergencyBackup;

		private static bool iDied;

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(1)]
		public static TextMeshProUGUI maintenanceCountdown;

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
		private static PlayerSnapshot playerSnapShotLast;

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
		private static PlayerSnapshot playerSnapShotNew;

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
		private static byte[] serverEncryptionKey;

		private static long serverEncryptionTime;

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
		private static string connectionError;

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
		private static TaskCompletionSource<Vector3> awaitingPos;

		private static void cleanEmergencyBackup()
		{
			string characterSavePath = Utils.CharacterSavePath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			string path = characterSavePath + directorySeparatorChar + Game.instance.m_playerProfile.m_filename + ".fch.signature";
			string characterSavePath2 = Utils.CharacterSavePath;
			directorySeparatorChar = Path.DirectorySeparatorChar;
			string text = characterSavePath2 + directorySeparatorChar + Game.instance.m_playerProfile.m_filename + ".fch.serverbackup";
			if (File.Exists(text) && File.Exists(path))
			{
				File.Delete(path);
				File.Delete(text);
				Utils.Log("Deleted emergency backup from " + text);
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		private static byte[] generateProfileSignature(byte[] profileData, byte[] key)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = SHA512.Create().ComputeHash(profileData);
			Aes aes = Aes.Create();
			aes.Key = key;
			MemoryStream memoryStream = new MemoryStream();
			CryptoStream cryptoStream = new CryptoStream(memoryStream, aes.CreateEncryptor(), CryptoStreamMode.Write);
			cryptoStream.Write(array, 0, array.Length);
			cryptoStream.FlushFinalBlock();
			cryptoStream.Close();
			ZPackage val = new ZPackage();
			val.Write(memoryStream.ToArray());
			val.Write(aes.IV);
			val.Write(serverEncryptionTime);
			return val.GetArray();
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		private static void receiveEncryptionKeyFromServer(ZRpc peerRpc, ZPackage keyPackage)
		{
			serverEncryptionKey = keyPackage.ReadByteArray();
			serverEncryptionTime = keyPackage.ReadLong();
		}

		public static void snapShotProfile()
		{
			ZNet instance = ZNet.instance;
			if (instance != null && !instance.IsServer() && (Object)(object)Player.m_localPlayer != (Object)null)
			{
				if (ZNet.instance.GetServerPing() < 1.5f)
				{
					playerSnapShotLast = playerSnapShotNew;
				}
				playerSnapShotNew = new PlayerSnapshot
				{
					inventory = ((Humanoid)Player.m_localPlayer).GetInventory().m_inventory.Select((ItemData d) => d.Clone()).ToList(),
					knownStations = Player.m_localPlayer.m_knownStations.ToDictionary((KeyValuePair<string, int> t) => t.Key, (KeyValuePair<string, int> t) => t.Value),
					knownTexts = Player.m_localPlayer.m_knownTexts.ToDictionary((KeyValuePair<string, string> t) => t.Key, (KeyValuePair<string, string> t) => t.Value)
				};
			}
		}
	}
	public enum Toggle
	{
		On = 1,
		Off = 0
	}
	public enum Intro
	{
		Disabled,
		Valkyrie,
		ValkyrieAndIntro
	}
	[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
	[PublicAPI]
	[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
	public class PlayerTemplate
	{
		[PublicAPI]
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		public class Position
		{
			public int x { get; set; }

			public int y { get; set; }

			public int z { get; set; }
		}

		public Dictionary<string, float> skills { get; set; } = new Dictionary<string, float>();


		public Dictionary<string, int> items { get; set; } = new Dictionary<string, int>();


		public List<Position> spawn { get; set; } = new List<Position>();

	}
	[BepInIncompatibility("org.bepinex.plugins.valheim_plus")]
	[BepInPlugin("org.bepinex.plugins.servercharacters", "Server Characters", "1.4.16")]
	[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
	[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
	public class ServerCharacters : BaseUnityPlugin
	{
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		private class ConfigurationManagerAttributes
		{
			[UsedImplicitly]
			public bool? Browsable = false;
		}

		private const string ModName = "Server Characters";

		private const string ModVersion = "1.4.16";

		private const string ModGUID = "org.bepinex.plugins.servercharacters";

		public static ServerCharacters selfReference = null;

		private static readonly Harmony harmony = new Harmony("org.bepinex.plugins.servercharacters");

		private float fixedUpdateCount;

		public int tickCount = int.MaxValue;

		public static int monotonicCounter = 0;

		public const int MaintenanceDisconnectMagic = 987345987;

		public const int CharacterNameDisconnectMagic = 498209834;

		public const int SingleCharacterModeDisconnectMagic = 845979243;

		public static readonly ConfigSync configSync = new ConfigSync("org.bepinex.plugins.servercharacters")
		{
			DisplayName = "Server Characters",
			CurrentVersion = "1.4.16",
			MinimumRequiredVersion = "1.4.16"
		};

		private static ConfigEntry<Toggle> serverConfigLocked = null;

		public static ConfigEntry<Toggle> singleCharacterMode = null;

		public static ConfigEntry<Toggle> backupOnlyMode = null;

		public static ConfigEntry<Toggle> hardcoreMode = null;

		public static ConfigEntry<Toggle> maintenanceMode = null;

		private static ConfigEntry<int> maintenanceTimer = null;

		public static ConfigEntry<int> backupsToKeep = null;

		public static ConfigEntry<int> autoSaveInterval = null;

		public static ConfigEntry<int> afkKickTimer = null;

		public static ConfigEntry<Toggle> excludeAdminsFromAfkCheck = null;

		public static ConfigEntry<string> webhookURL = null;

		private static ConfigEntry<string> webhookUsernameMaintenance = null;

		private static ConfigEntry<string> maintenanceEnabledText = null;

		private static ConfigEntry<string> maintenanceFinishedText = null;

		private static ConfigEntry<string> maintenanceAbortedText = null;

		private static ConfigEntry<string> maintenanceStartedText = null;

		public static ConfigEntry<string> loginMessage = null;

		public static ConfigEntry<string> firstLoginMessage = null;

		public static ConfigEntry<Toggle> postFirstLoginToWebhook = null;

		public static ConfigEntry<string> webhookUsernameOther = null;

		public static ConfigEntry<string> serverKey = null;

		public static ConfigEntry<string> serverListenAddress = null;

		public static ConfigEntry<Intro> newCharacterIntro = null;

		public static ConfigEntry<Toggle> storePoison = null;

		public static readonly CustomSyncedValue<string> playerTemplate = new CustomSyncedValue<string>(configSync, "PlayerTemplate", readCharacterTemplate());

		public static ManualLogSource logger => ((BaseUnityPlugin)selfReference).Logger;

		private static string pluginDir => Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);

		private ConfigEntry<T> config<[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] T>(string group, string name, T value, ConfigDescription description, bool synchronizedSetting = true)
		{
			ConfigEntry<T> val = ((BaseUnityPlugin)this).Config.Bind<T>(group, name, value, description);
			configSync.AddConfigEntry<T>(val).SynchronizedConfig = synchronizedSetting;
			return val;
		}

		private ConfigEntry<T> config<[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] T>(string group, string name, T value, string description, bool synchronizedSetting = true)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			return config(group, name, value, new ConfigDescription(description, (AcceptableValueBase)null, Array.Empty<object>()), synchronizedSetting);
		}

		public void Awake()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c7: Expected O, but got Unknown
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Expected O, but got Unknown
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: Expected O, but got Unknown
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b3: Expected O, but got Unknown
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Expected O, but got Unknown
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_034f: Expected O, but got Unknown
			//IL_0378: Unknown result type (might be due to invalid IL or missing references)
			//IL_0383: Expected O, but got Unknown
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ae: Expected O, but got Unknown
			//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Expected O, but got Unknown
			//IL_03fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0405: Expected O, but got Unknown
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Expected O, but got Unknown
			//IL_0462: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Expected O, but got Unknown
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_0581: Expected O, but got Unknown
			selfReference = this;
			serverConfigLocked = config("1 - General", "Lock Configuration", Toggle.On, "If on, the configuration is locked and can be changed by server admins only.");
			configSync.AddLockingConfigEntry<Toggle>(serverConfigLocked);
			afkKickTimer = config("1 - General", "AFK Kick Timer", 0, new ConfigDescription("Automatically kicks players, if they haven't moved at all in the configured time. In minutes. 0 is disabled.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 30), Array.Empty<object>()));
			excludeAdminsFromAfkCheck = config("1 - General", "Exclude Admins from AFK check", Toggle.Off, new ConfigDescription("Can be used to exclude admins from the AFK kick timer.", (AcceptableValueBase)null, Array.Empty<object>()));
			webhookURL = config("1 - General", "Discord Webhook URL", "", new ConfigDescription("Discord API endpoint to announce maintenance.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			loginMessage = config("1 - General", "Login Message", "I have arrived!", new ConfigDescription("Message to shout on login. Leave empty to not shout anything.", (AcceptableValueBase)null, Array.Empty<object>()));
			webhookUsernameOther = config("1 - General", "Discord Username Other", "Server Characters", new ConfigDescription("Username to be used for non-maintenance related posts to Discord.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			hardcoreMode = config("2 - Save Files", "Hardcore mode", Toggle.Off, "If set to on, players will be kicked from the server and their save file on the server will be deleted, if they die.");
			singleCharacterMode = config("2 - Save Files", "Single Character Mode", Toggle.Off, "If set to on, each SteamID / Xbox ID can create one character only on this server. Has no effect for admins.");
			backupOnlyMode = config("2 - Save Files", "Backup only mode", Toggle.Off, "Enabling this will not enforce the server profile anymore. DO NOT ENABLE THIS IF YOU DON'T KNOW EXACTLY WHAT YOU ARE DOING!");
			backupsToKeep = config("2 - Save Files", "Number of backups to keep", 25, new ConfigDescription("Sets the number of backups that should be stored for each character.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 50), Array.Empty<object>()));
			autoSaveInterval = config("2 - Save Files", "Auto save interval", 30, new ConfigDescription("Minutes between auto saves of characters and the world.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(1, 120), Array.Empty<object>()));
			autoSaveInterval.SettingChanged += [<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)] (object _, EventArgs _) =>
			{
				Game.m_saveInterval = autoSaveInterval.Value * 60;
			};
			storePoison = config("2 - Save Files", "Store poison debuff", Toggle.On, new ConfigDescription("If on, poison debuffs are stored in the save file on logout and applied on login, to prevent users from logging out if they are poisoned, to clear the debuff.", (AcceptableValueBase)null, Array.Empty<object>()));
			maintenanceMode = config("3 - Maintenance", "Maintenance Mode", Toggle.Off, "If set to on, a timer will start. If the timer elapses, all non-admins will be disconnected, the world will be saved and only admins will be able to connect to the server, until maintenance mode is toggled to off.");
			maintenanceMode.SettingChanged += toggleMaintenanceMode;
			maintenanceTimer = config("3 - Maintenance", "Maintenance Timer", 300, new ConfigDescription("Time in seconds that has to pass, before the maintenance mode becomes active.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(10, 1800), Array.Empty<object>()));
			webhookUsernameMaintenance = config("3 - Maintenance", "Discord Username Maintenance", "Maintenance Bot", new ConfigDescription("Username to be used for maintenance related posts to Discord.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			maintenanceEnabledText = config("3 - Maintenance", "Maintenance enabled text", "Maintenance mode enabled. All non-admins will be disconnected in {time}.", new ConfigDescription("Message to be posted to Discord, when the maintenance mode has been toggled to 'On'. Leave empty to not post anything. Use {time} for the time until the maintenance starts.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			maintenanceFinishedText = config("3 - Maintenance", "Maintenance finished text", "Maintenance has been disabled and the server is back online. Have fun!", new ConfigDescription("Message to be posted to Discord, when the maintenance mode has been toggled to 'Off'. Leave empty to not post anything.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			maintenanceAbortedText = config("3 - Maintenance", "Maintenance aborted text", "Maintenance has been aborted.", new ConfigDescription("Message to be posted to Discord, when the maintenance has been aborted. Leave empty to not post anything.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			maintenanceStartedText = config("3 - Maintenance", "Maintenance started text", "Maintenance has started and players will be unable to connect.", new ConfigDescription("Message to be posted to Discord, when the maintenance has begun. Leave empty to not post anything.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			firstLoginMessage = config("3 - First Login", "First Login Message", "A new player logged in for the first time: {name}", new ConfigDescription("Message to display if a player logs in for the very first time. Leave empty to not display anything.", (AcceptableValueBase)null, Array.Empty<object>()));
			newCharacterIntro = config("3 - First Login", "Intro", Intro.ValkyrieAndIntro, new ConfigDescription("Sets the kind of intro new characters will get.", (AcceptableValueBase)null, Array.Empty<object>()));
			postFirstLoginToWebhook = config("3 - First Login", "First Login Webhook", Toggle.Off, new ConfigDescription("If on, the first login message is posted to the webhook as well.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			serverKey = config("4 - Other", "Server key", "", new ConfigDescription("DO NOT TOUCH THIS! DO NOT SHARE THIS! Encryption key used for emergency profile backups. DO NOT SHARE THIS! DO NOT TOUCH THIS!", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			serverListenAddress = config("4 - Other", "Webinterface listen address", "127.0.0.1:5982", new ConfigDescription("The address the webinterface API should listen on. Clear this value, if you don't use the webinterface.", (AcceptableValueBase)null, new object[1]
			{
				new ConfigurationManagerAttributes()
			}), synchronizedSetting: false);
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			harmony.PatchAll(executingAssembly);
			FileSystemWatcher fileSystemWatcher = new FileSystemWatcher(Paths.ConfigPath, "maintenance");
			fileSystemWatcher.Created += maintenanceFileEvent;
			fileSystemWatcher.Deleted += maintenanceFileEvent;
			fileSystemWatcher.IncludeSubdirectories = true;
			fileSystemWatcher.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher.EnableRaisingEvents = true;
			FileSystemWatcher fileSystemWatcher2 = new FileSystemWatcher(pluginDir, "CharacterTemplate.yml");
			fileSystemWatcher2.Created += templateFileEvent;
			fileSystemWatcher2.Changed += templateFileEvent;
			fileSystemWatcher2.Renamed += templateFileEvent;
			fileSystemWatcher2.Deleted += templateFileEvent;
			fileSystemWatcher2.IncludeSubdirectories = true;
			fileSystemWatcher2.SynchronizingObject = ThreadingHelper.SynchronizingObject;
			fileSystemWatcher2.EnableRaisingEvents = true;
			ServerSide.generateServerKey();
			harmony.Patch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(AccessTools.DeclaredMethod(typeof(ServerCharacters), "Initialize", (Type[])null, (Type[])null)), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}

		public static void Initialize()
		{
			//IL_01e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Expected O, but got Unknown
			harmony.Unpatch((MethodBase)AccessTools.DeclaredMethod(typeof(FejdStartup), "Awake", (Type[])null, (Type[])null), (HarmonyPatchType)2, harmony.Id);
			if (!Utility.IsNullOrWhiteSpace(serverListenAddress.Value))
			{
				WebInterfaceAPI.StartServer();
			}
			Directory.CreateDirectory(Utils.CharacterSavePath);
			string characterFolderPath = PlayerProfile.GetCharacterFolderPath((FileSource)3);
			string[] files;
			if (Directory.Exists(characterFolderPath))
			{
				files = Directory.GetFiles(characterFolderPath);
				for (int i = 0; i < files.Length; i++)
				{
					FileInfo fileInfo = new FileInfo(files[i]);
					if (Utils.IsServerCharactersFilePattern(fileInfo.Name) || fileInfo.Name == "backups")
					{
						string fullName = fileInfo.FullName;
						string characterSavePath = Utils.CharacterSavePath;
						char directorySeparatorChar = Path.DirectorySeparatorChar;
						Directory.Move(fullName, characterSavePath + directorySeparatorChar + fileInfo.Name);
					}
				}
			}
			files = Directory.GetFiles(Utils.CharacterSavePath);
			for (int i = 0; i < files.Length; i++)
			{
				FileInfo fileInfo2 = new FileInfo(files[i]);
				if (fileInfo2.Name.EndsWith(".fch", StringComparison.Ordinal) && Regex.IsMatch(fileInfo2.Name.Split(new char[1] { '_' })[0], "^\\d+$"))
				{
					string? directoryName = fileInfo2.DirectoryName;
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					string destFileName = directoryName + directorySeparatorChar + "Steam_" + fileInfo2.Name;
					fileInfo2.MoveTo(destFileName);
				}
			}
			files = Directory.GetFiles(Utils.CharacterSavePath);
			for (int i = 0; i < files.Length; i++)
			{
				FileInfo fileInfo3 = new FileInfo(files[i]);
				if (Utils.IsServerCharactersFilePattern(fileInfo3.Name))
				{
					Utils.ProfileName key = default(Utils.ProfileName);
					string[] array = fileInfo3.Name.Split(new char[1] { '_' });
					key.id = array[0] + "_" + array[1];
					key.name = array[2].Split(new char[1] { '.' })[0];
					PlayerProfile val = new PlayerProfile(fileInfo3.Name.Replace(".fch", ""), (FileSource)1);
					val.Load();
					Utils.Cache.profiles[key] = val;
				}
			}
		}

		private static void maintenanceFileEvent(object s, EventArgs e)
		{
			string configPath = Paths.ConfigPath;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			Toggle toggle = (File.Exists(configPath + directorySeparatorChar + "maintenance") ? Toggle.On : Toggle.Off);
			SyncedConfigEntry<Toggle> syncedConfigEntry = ConfigSync.ConfigData<Toggle>(maintenanceMode);
			if (syncedConfigEntry.LocalBaseValue == null)
			{
				maintenanceMode.Value = toggle;
			}
			else
			{
				syncedConfigEntry.LocalBaseValue = toggle;
			}
		}

		private static void templateFileEvent(object s, EventArgs e)
		{
			playerTemplate.AssignLocalValue(readCharacterTemplate());
		}

		private static string readCharacterTemplate()
		{
			string text = pluginDir;
			char directorySeparatorChar = Path.DirectorySeparatorChar;
			string path = text + directorySeparatorChar + "CharacterTemplate.yml";
			if (!File.Exists(path))
			{
				return "";
			}
			return File.ReadAllText(path);
		}

		private void toggleMaintenanceMode(object s, EventArgs e)
		{
			if (maintenanceMode.GetToggle())
			{
				string text = maintenanceEnabledText.Value.Replace("{time}", Utils.getHumanFriendlyTime(maintenanceTimer.Value));
				Player localPlayer = Player.m_localPlayer;
				if (localPlayer != null)
				{
					((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null);
				}
				Utils.Log(text);
				tickCount = maintenanceTimer.Value;
				WebInterfaceAPI.SendMaintenanceMessage(new Maintenance
				{
					startTime = DateTimeOffset.Now.ToUnixTimeSeconds() + tickCount,
					maintenanceActive = false
				});
				if (configSync.IsSourceOfTruth)
				{
					string configPath = Paths.ConfigPath;
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					File.Create(configPath + directorySeparatorChar + "maintenance");
					Utils.PostToDiscord(text, webhookUsernameMaintenance.Value);
				}
				return;
			}
			if (configSync.IsSourceOfTruth)
			{
				string configPath2 = Paths.ConfigPath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				File.Delete(configPath2 + directorySeparatorChar + "maintenance");
				Utils.PostToDiscord((tickCount <= maintenanceTimer.Value) ? maintenanceAbortedText.Value : maintenanceFinishedText.Value, webhookUsernameMaintenance.Value);
				WebInterfaceAPI.SendMaintenanceMessage(new Maintenance
				{
					startTime = 0L,
					maintenanceActive = false
				});
			}
			if (tickCount <= maintenanceTimer.Value)
			{
				Player localPlayer2 = Player.m_localPlayer;
				if (localPlayer2 != null)
				{
					((Character)localPlayer2).Message((MessageType)2, "Maintenance aborted", 0, (Sprite)null);
				}
				Utils.Log("Maintenance aborted");
				tickCount = int.MaxValue;
			}
		}

		private void FixedUpdate()
		{
			fixedUpdateCount += Time.fixedDeltaTime;
			if ((double)fixedUpdateCount < 1.0)
			{
				return;
			}
			ZNet instance = ZNet.instance;
			if ((instance == null || !instance.IsServer()) && ClientSide.serverCharacter)
			{
				ClientSide.snapShotProfile();
			}
			if (tickCount <= 0)
			{
				ZNet instance2 = ZNet.instance;
				if (instance2 != null && instance2.IsServer())
				{
					foreach (ZNetPeer peer in ZNet.instance.GetPeers())
					{
						if (!ZNet.instance.ListContainsId(ZNet.instance.m_adminList, peer.m_rpc.GetSocket().GetHostName()))
						{
							ZNet.instance.InternalKick(peer);
							Utils.Log("Kicked non-admin client " + Utils.GetPlayerID(peer.m_rpc.GetSocket().GetHostName()) + ", reason: Maintenance started.");
						}
					}
					ZNet.instance.SaveWorldAndPlayerProfiles();
					Utils.Log("Maintenance started. World has been saved.");
					Utils.PostToDiscord(maintenanceStartedText.Value, webhookUsernameMaintenance.Value);
					WebInterfaceAPI.SendMaintenanceMessage(new Maintenance
					{
						startTime = DateTimeOffset.Now.ToUnixTimeSeconds(),
						maintenanceActive = true
					});
				}
				tickCount = int.MaxValue;
			}
			fixedUpdateCount -= 1f;
			tickCount--;
			monotonicCounter++;
			if (Object.op_Implicit((Object)(object)ClientSide.maintenanceCountdown))
			{
				((TMP_Text)ClientSide.maintenanceCountdown).text = ((!maintenanceMode.GetToggle()) ? "" : ((tickCount < 1073741823) ? ("Maintenance in: " + TimeSpan.FromSeconds(tickCount).ToString("c")) : "Maintenance active"));
			}
		}
	}
	[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
	[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
	public static class ServerSide
	{
		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		private static class PatchZNetOnNewConnection
		{
			private static byte[] deriveKey(long time)
			{
				return new Rfc2898DeriveBytes(ServerCharacters.serverKey.Value, BitConverter.GetBytes(time), 1000).GetBytes(32);
			}

			[UsedImplicitly]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				//IL_01af: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b5: Expected O, but got Unknown
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.IsServer())
				{
					if (ServerCharacters.maintenanceMode.GetToggle() && !isAdmin(peer.m_rpc))
					{
						peer.m_rpc.Invoke("Error", new object[1] { 987345987 });
						Utils.Log("Non-admin client " + Utils.GetPlayerID(peer.m_rpc.GetSocket().GetHostName()) + " tried to connect during maintenance and got disconnected");
						__instance.Disconnect(peer);
					}
					peer.m_rpc.Register<ZPackage>("ServerCharacters PlayerProfile", Shared.receiveCompressedFromPeer(delegate(ZRpc peerRpc, byte[] profileData)
					{
						onReceivedProfile(peerRpc, profileData);
					}));
					peer.m_rpc.Register<ZPackage>("ServerCharacters CheckSignature", Shared.receiveCompressedFromPeer(onReceivedSignature));
					peer.m_rpc.Register<ZPackage>("ServerCharacters PlayerInventory", Shared.receiveCompressedFromPeer(onReceivedInventory));
					peer.m_rpc.Register<ZPackage>("ServerCharacters PlayerDied", Shared.receiveCompressedFromPeer(onPlayerDied));
					peer.m_rpc.Register<string, string, string>("ServerCharacters ResetSkill", (Action<ZRpc, string, string, string>)onResetSkill);
					peer.m_rpc.Register<string, int, string, string>("ServerCharacters RaiseSkill", (Method<string, int, string, string>)onRaiseSkill);
					peer.m_rpc.Register<string, string>("ServerCharacters GetPlayerPos", (Action<ZRpc, string, string>)onGetPlayerPos);
					peer.m_rpc.Register<string, int, string, string>("ServerCharacters GiveItem", (Method<string, int, string, string>)onGiveItem);
					peer.m_rpc.Register<string, string, Vector3>("ServerCharacters SendOwnPos", (Action<ZRpc, string, string, Vector3>)onSendOwnPos);
					long ticks = DateTime.Now.Ticks;
					byte[] array = deriveKey(ticks);
					ZPackage val = new ZPackage();
					val.Write(array);
					val.Write(ticks);
					peer.m_rpc.Invoke("ServerCharacters KeyExchange", new object[1] { val });
					if ((int)ZNet.m_onlineBackend != 0)
					{
						ServerCharacters.logger.LogFatal((object)"This server is not running on Steam, which is required for this mod to function. Please disable PlayFab (Crossplay) and restart the server.");
					}
				}
			}

			private static void onPlayerDied(ZRpc peerRpc, byte[] profileData)
			{
				PlayerProfile val = onReceivedProfile(peerRpc, profileData);
				if (val != null)
				{
					backupProfile(val);
					string characterSavePath = Utils.CharacterSavePath;
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					string text = characterSavePath + directorySeparatorChar + val.m_filename + ".fch";
					File.Delete(text + ".old");
					File.Move(text, text + ".old");
				}
			}

			[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
			private static PlayerProfile onReceivedProfile(ZRpc peerRpc, byte[] profileData)
			{
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0008: Expected O, but got Unknown
				//IL_00de: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Expected O, but got Unknown
				PlayerProfile val = new PlayerProfile((string)null, (FileSource)1);
				if (!val.LoadPlayerProfileFromBytes(profileData))
				{
					Utils.Log("Encountered invalid data for bytes from ID " + Utils.GetPlayerID(peerRpc.m_socket.GetHostName()));
					return null;
				}
				if (Shared.CharacterNameIsForbidden(val.GetName()))
				{
					peerRpc.Invoke("Error", new object[1] { 498209834 });
					ZNet.instance.Disconnect(ZNet.instance.GetPeer(peerRpc));
					Utils.Log("Client " + Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + " tried to connect with a bad profile name '" + val.GetName() + "' and got disconnected");
					return null;
				}
				val = new PlayerProfile(Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + "_" + val.GetName().ToLower(), (FileSource)1);
				val.LoadPlayerProfileFromBytes(profileData);
				if (!File.Exists(val.GetPath()) && ServerCharacters.postFirstLoginToWebhook.Value == Toggle.On)
				{
					Utils.PostToDiscord(ServerCharacters.firstLoginMessage.Value.Replace("{name}", val.GetName()), ServerCharacters.webhookUsernameOther.Value);
				}
				val.SavePlayerToDisk();
				Utils.Log("Saved player profile data for " + val.m_filename);
				return val;
			}

			private static void onReceivedInventory(ZRpc peerRpc, byte[] inventoryData)
			{
				Inventories[Utils.ProfileName.fromPeer(ZNet.instance.GetPeer(peerRpc))] = inventoryData;
			}

			private static void onReceivedSignature(ZRpc peerRpc, byte[] signedProfile)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Expected O, but got Unknown
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Expected O, but got Unknown
				//IL_0196: Unknown result type (might be due to invalid IL or missing references)
				//IL_019b: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Expected O, but got Unknown
				ZPackage val = new ZPackage(signedProfile);
				byte[] array = val.ReadByteArray();
				byte[] signature = val.ReadByteArray();
				long num = VerifySignature(array, signature);
				if (num <= 0)
				{
					Utils.Log("Client " + Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + " tried to restore an emergency backup, but signature was invalid. Skipping.");
					return;
				}
				PlayerProfile val2 = new PlayerProfile((string)null, (FileSource)0);
				if (!val2.LoadPlayerProfileFromBytes(array) || Shared.CharacterNameIsForbidden(val2.GetName()))
				{
					Utils.Log("Client " + Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + " tried to restore an emergency backup, but the profile data is corrupted.");
					return;
				}
				val2 = new PlayerProfile(Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + "_" + val2.GetName().ToLower(), (FileSource)1);
				val2.LoadPlayerProfileFromBytes(array);
				string characterSavePath = Utils.CharacterSavePath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				FileInfo fileInfo = new FileInfo(characterSavePath + directorySeparatorChar + val2.m_filename + ".fch");
				if (!fileInfo.Exists)
				{
					Utils.Log("Client " + Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + " tried to restore an emergency backup for the character '" + val2.m_filename + "' that does not belong to this server. Skipping.");
					return;
				}
				DateTime lastWriteTime = fileInfo.LastWriteTime;
				if (new DateTime(num) <= lastWriteTime)
				{
					Utils.Log("Client " + Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + " tried to restore an old emergency backup. Skipping.");
					return;
				}
				if (!Inventories.TryGetValue(Utils.ProfileName.fromPeer(ZNet.instance.GetPeer(peerRpc)), out var value))
				{
					PlayerProfile val3 = new PlayerProfile(val2.m_filename, (FileSource)0);
					val3.LoadPlayerFromDisk();
					value = ReadInventoryFromProfile(val3);
				}
				PatchPlayerProfileInventory(val2, value);
				val2.SavePlayerToDisk();
				Utils.Log("Client " + Utils.GetPlayerID(peerRpc.m_socket.GetHostName()) + " succesfully restored an emergency backup for " + val2.m_filename + ".");
			}

			private static long VerifySignature(byte[] profileData, byte[] signature)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				byte[] first = SHA512.Create().ComputeHash(profileData);
				ZPackage val = new ZPackage(signature);
				byte[] buffer = val.ReadByteArray();
				byte[] iV = val.ReadByteArray();
				long num = val.ReadLong();
				byte[] key = deriveKey(num);
				Aes aes = Aes.Create();
				aes.Key = key;
				aes.IV = iV;
				CryptoStream cryptoStream = new CryptoStream(new MemoryStream(buffer), aes.CreateDecryptor(), CryptoStreamMode.Read);
				MemoryStream memoryStream = new MemoryStream();
				cryptoStream.CopyTo(memoryStream);
				byte[] second = memoryStream.ToArray();
				if (!first.SequenceEqual(second))
				{
					return 0L;
				}
				return num;
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		private class PatchZNetDisconnect
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Prefix(ZNetPeer peer)
			{
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer() && peerProfileNameMap.TryGetValue(peer, out var value) && Inventories.TryGetValue(value, out var value2))
				{
					Inventories.Remove(value);
					PlayerProfile val = new PlayerProfile(value.id + "_" + value.name.ToLower(), (FileSource)1);
					if (val.LoadPlayerFromDisk())
					{
						string characterSavePath = Utils.CharacterSavePath;
						char directorySeparatorChar = Path.DirectorySeparatorChar;
						FileInfo fileInfo = new FileInfo(characterSavePath + directorySeparatorChar + val.GetFilename() + ".fch");
						DateTime lastWriteTime = fileInfo.LastWriteTime;
						PatchPlayerProfileInventory(val, value2);
						val.SavePlayerToDisk();
						File.SetLastWriteTime(fileInfo.FullName, lastWriteTime);
					}
				}
				peerProfileNameMap.Remove(peer);
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		private class SendConfigsAfterLogin
		{
			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			private class BufferingSocket : ISocket
			{
				public volatile bool finished;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_004c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0052: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[CompilerGenerated]
			private sealed class <>c__DisplayClass2_0
			{
				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public ZNetPeer peer;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public ZNet __instance;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public ZRpc rpc;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public BufferingSocket __state;

				[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
				internal bool <Postfix>b__1(WebinterfacePlayer p)
				{
					return p.Id == Utils.GetPlayerID(peer.m_rpc.GetSocket().GetHostName());
				}
			}

			[HarmonyPriority(800)]
			private static void Prefix([<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] ref BufferingSocket __state, ZNet __instance, ZRpc rpc)
			{
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				if (__instance.IsServer())
				{
					__state = new BufferingSocket(rpc.GetSocket());
					rpc.m_socket = (ISocket)(object)__state;
					ZNetPeer peer = ZNet.instance.GetPeer(rpc);
					if (peer != null && (int)ZNet.m_onlineBackend != 0)
					{
						peer.m_socket = (ISocket)(object)__state;
					}
				}
			}

			private static void Postfix(BufferingSocket __state, ZNet __instance, ZRpc rpc)
			{
				<>c__DisplayClass2_0 CS$<>8__locals0 = new <>c__DisplayClass2_0();
				CS$<>8__locals0.__instance = __instance;
				CS$<>8__locals0.rpc = rpc;
				CS$<>8__locals0.__state = __state;
				if (CS$<>8__locals0.__instance.IsServer())
				{
					CS$<>8__locals0.peer = CS$<>8__locals0.__instance.GetPeer(CS$<>8__locals0.rpc);
					peerProfileNameMap[CS$<>8__locals0.peer] = Utils.ProfileName.fromPeer(CS$<>8__locals0.peer);
					((MonoBehaviour)CS$<>8__locals0.__instance).StartCoroutine(sendAsync());
				}
				[IteratorStateMachine(typeof(<>c__DisplayClass2_0.<<Postfix>g__sendAsync|0>d))]
				IEnumerator sendAsync()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass2_0.<<Postfix>g__sendAsync|0>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}
		}

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "InternalKick", new Type[] { typeof(ZNetPeer) })]
		private static class PatchZNetKick
		{
			[CompilerGenerated]
			private sealed class <>c__DisplayClass2_0
			{
				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public ZNetPeer peer;

				public int endTime;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				public ZNet __instance;

				internal bool <Postfix>b__1()
				{
					if (peer.m_socket.IsConnected())
					{
						return endTime > ServerCharacters.monotonicCounter;
					}
					return false;
				}
			}

			[CompilerGenerated]
			private sealed class <Transpiler>d__1 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private IEnumerable<CodeInstruction> instructions;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				public IEnumerable<CodeInstruction> <>3__instructions;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private List<CodeInstruction> <instructionList>5__2;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private List<CodeInstruction>.Enumerator <>7__wrap2;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				private CodeInstruction <instruction>5__4;

				CodeInstruction IEnumerator<CodeInstruction>.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <Transpiler>d__1(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || (uint)(num - 1) <= 1u)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<instructionList>5__2 = null;
					<>7__wrap2 = default(List<CodeInstruction>.Enumerator);
					<instruction>5__4 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					bool result;
					try
					{
						switch (<>1__state)
						{
						default:
							result = false;
							goto end_IL_0000;
						case 0:
							<>1__state = -1;
							<instructionList>5__2 = instructions.ToList();
							<>7__wrap2 = <instructionList>5__2.GetEnumerator();
							<>1__state = -3;
							break;
						case 1:
							<>1__state = -3;
							if (!(<instruction>5__4.opcode == OpCodes.Call) || !CodeInstructionExtensions.OperandIs(<instruction>5__4, (MemberInfo)DisconnectSender))
							{
								<instruction>5__4 = null;
								break;
							}
							<>2__current = <instructionList>5__2.Last();
							<>1__state = 2;
							result = true;
							goto end_IL_0000;
						case 2:
							<>1__state = -3;
							result = false;
							<>m__Finally1();
							goto end_IL_0000;
						}
						if (<>7__wrap2.MoveNext())
						{
							<instruction>5__4 = <>7__wrap2.Current;
							<>2__current = <instruction>5__4;
							<>1__state = 1;
							result = true;
						}
						else
						{
							<>m__Finally1();
							<>7__wrap2 = default(List<CodeInstruction>.Enumerator);
							result = false;
						}
						end_IL_0000:;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
					return result;
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					((IDisposable)<>7__wrap2).Dispose();
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}

				[DebuggerHidden]
				[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__1 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__1(0);
					}
					<Transpiler>d__.instructions = <>3__instructions;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			private static readonly MethodInfo DisconnectSender = AccessTools.DeclaredMethod(typeof(ZNet), "SendDisconnect", new Type[1] { typeof(ZNetPeer) }, (Type[])null);

			[IteratorStateMachine(typeof(<Transpiler>d__1))]
			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__1(-2)
				{
					<>3__instructions = instructions
				};
			}

			[UsedImplicitly]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				<>c__DisplayClass2_0 CS$<>8__locals0 = new <>c__DisplayClass2_0();
				CS$<>8__locals0.peer = peer;
				CS$<>8__locals0.__instance = __instance;
				if (!CS$<>8__locals0.peer.m_socket.IsConnected())
				{
					CS$<>8__locals0.__instance.Disconnect(CS$<>8__locals0.peer);
					return;
				}
				CS$<>8__locals0.endTime = ServerCharacters.monotonicCounter + 30;
				((MonoBehaviour)CS$<>8__locals0.__instance).StartCoroutine(shutdownAfterSave());
				[IteratorStateMachine(typeof(<>c__DisplayClass2_0.<<Postfix>g__shutdownAfterSave|0>d))]
				IEnumerator shutdownAfterSave()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass2_0.<<Postfix>g__shutdownAfterSave|0>d(0)
					{
						<>4__this = CS$<>8__locals0
					};
				}
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		[HarmonyPatch(typeof(PlayerProfile), "SavePlayerToDisk")]
		private static class PatchPlayerProfileSave_Server
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Postfix(PlayerProfile __instance)
			{
				ZNet instance = ZNet.instance;
				if (instance != null && instance.IsServer())
				{
					backupProfile(__instance);
				}
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		private class DummyPlayer : Player
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			public override void Message(MessageType type, string msg, int amount = 0, [<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] Sprite icon = null)
			{
			}
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		[HarmonyPatch(typeof(ServerSide), "ConsumePlayerSaveUntilInventory")]
		private static class PlayerProfileConsumptionStartInventory
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
			{
				MethodInfo endOperand = AccessTools.DeclaredMethod(typeof(Inventory), "Load", (Type[])null, (Type[])null);
				return PlayerProfileConsumeUntil(ilGenerator, endOperand);
			}
		}

		[HarmonyPatch(typeof(ServerSide), "ConsumePlayerSaveUntilSkills")]
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		private static class PlayerProfileConsumptionStartSkills
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator ilGenerator)
			{
				MethodInfo endOperand = AccessTools.DeclaredMethod(typeof(Skills), "Load", (Type[])null, (Type[])null);
				return PlayerProfileConsumeUntil(ilGenerator, endOperand);
			}
		}

		[CompilerGenerated]
		private sealed class <PlayerProfileConsumeUntil>d__22 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private CodeInstruction <>2__current;

			private int <>l__initialThreadId;

			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			private ILGenerator ilGenerator;

			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			public ILGenerator <>3__ilGenerator;

			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			private MethodInfo endOperand;

			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			public MethodInfo <>3__endOperand;

			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
			private List<CodeInstruction> <instructions>5__2;

			private int <i>5__3;

			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			private MethodInfo <method>5__4;

			private int <j>5__5;

			CodeInstruction IEnumerator<CodeInstruction>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <PlayerProfileConsumeUntil>d__22(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<instructions>5__2 = null;
				<method>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0193: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Expected O, but got Unknown
				//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
				//IL_01be: Expected O, but got Unknown
				//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01df: Expected O, but got Unknown
				//IL_0206: Unknown result type (might be due to invalid IL or missing references)
				//IL_0210: Expected O, but got Unknown
				//IL_028e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0298: Expected O, but got Unknown
				//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_02e0: Expected O, but got Unknown
				//IL_038e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0398: Expected O, but got Unknown
				//IL_0487: Unknown result type (might be due to invalid IL or missing references)
				//IL_0491: Expected O, but got Unknown
				//IL_04a9: Unknown result type (might be due to invalid IL or missing references)
				//IL_04ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_04d1: Expected O, but got Unknown
				//IL_05e1: Unknown result type (might be due to invalid IL or missing references)
				//IL_05eb: Expected O, but got Unknown
				//IL_036c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0376: Expected O, but got Unknown
				//IL_066c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0676: Expected O, but got Unknown
				//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
				//IL_0301: Unknown result type (might be due to invalid IL or missing references)
				//IL_032d: Expected O, but got Unknown
				//IL_06d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_06dd: Expected O, but got Unknown
				//IL_06af: Unknown result type (might be due to invalid IL or missing references)
				//IL_06b9: Expected O, but got Unknown
				//IL_0465: Unknown result type (might be due to invalid IL or missing references)
				//IL_046f: Expected O, but got Unknown
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_0236: Unknown result type (might be due to invalid IL or missing references)
				//IL_0262: Expected O, but got Unknown
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0150: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Expected O, but got Unknown
				int num;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<instructions>5__2 = PatchProcessor.GetOriginalInstructions((MethodBase)AccessTools.DeclaredMethod(typeof(Player), "Load", (Type[])null, (Type[])null), ilGenerator).ToList();
					<i>5__3 = 0;
					goto IL_072f;
				case 1:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Ldnull, (object)null);
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Newobj, (object)typeof(Inventory).GetConstructors()[0]);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					goto IL_071f;
				case 6:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(Type), "GetTypeFromHandle", (Type[])null, (Type[])null));
					<>1__state = 7;
					return true;
				case 7:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Call, (object)AccessTools.DeclaredMethod(typeof(AccessTools), "CreateInstance", new Type[1] { typeof(Type) }, (Type[])null));
					<>1__state = 8;
					return true;
				case 8:
					<>1__state = -1;
					goto IL_071f;
				case 9:
					<>1__state = -1;
					goto IL_071f;
				case 10:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 11;
					return true;
				case 11:
					<>1__state = -1;
					goto IL_071f;
				case 12:
					<>1__state = -1;
					goto IL_071f;
				case 13:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
					<>1__state = 14;
					return true;
				case 14:
					<>1__state = -1;
					<>2__current = new CodeInstruction(OpCodes.Ret, (object)null)
					{
						labels = <instructions>5__2[<i>5__3 + 1].labels
					};
					<>1__state = 15;
					return true;
				case 15:
					<>1__state = -1;
					break;
				case 16:
					<>1__state = -1;
					num = <j>5__5 + 1;
					<j>5__5 = num;
					goto IL_060c;
				case 17:
					<>1__state = -1;
					goto IL_071f;
				case 18:
					<>1__state = -1;
					goto IL_071f;
				case 19:
					<>1__state = -1;
					goto IL_071f;
				case 20:
					{
						<>1__state = -1;
						<method>5__4 = null;
						goto IL_071f;
					}
					IL_072f:
					if (<i>5__3 >= <instructions>5__2.Count)
					{
						break;
					}
					if (<instructions>5__2[<i>5__3].opcode == OpCodes.Ldarg_0 && <instructions>5__2[<i>5__3 + 1].opcode == OpCodes.Ldfld)
					{
						if (<instructions>5__2[<i>5__3 + 1].operand is FieldInfo fieldInfo)
						{
							Type fieldType = fieldInfo.FieldType;
							if ((object)fieldType != null && fieldType.IsClass)
							{
								if (fieldInfo.FieldType == typeof(Inventory))
								{
									<>2__current = new CodeInstruction(OpCodes.Ldnull, (object)null)
									{
										labels = <instructions>5__2[<i>5__3++].labels
									};
									<>1__state = 1;
									return true;
								}
								<>2__current = new CodeInstruction(OpCodes.Ldtoken, (object)fieldInfo.FieldType)
								{
									labels = <instructions>5__2[<i>5__3++].labels
								};
								<>1__state = 6;
								return true;
							}
						}
						<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null)
						{
							labels = <instructions>5__2[<i>5__3++].labels
						};
						<>1__state = 9;
						return true;
					}
					if (<instructions>5__2[<i>5__3].opcode == OpCodes.Stfld)
					{
						<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
						<>1__state = 10;
						return true;
					}
					if (<instructions>5__2[<i>5__3].opcode == OpCodes.Ldarg_1)
					{
						<instructions>5__2[<i>5__3].opcode = OpCodes.Ldarg_0;
						<>2__current = <instructions>5__2[<i>5__3];
						<>1__state = 12;
						return true;
					}
					if (<instructions>5__2[<i>5__3].opcode == OpCodes.Callvirt && CodeInstructionExtensions.OperandIs(<instructions>5__2[<i>5__3], (MemberInfo)endOperand))
					{
						<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
						<>1__state = 13;
						return true;
					}
					if (<instructions>5__2[<i>5__3].opcode == OpCodes.Callvirt || <instructions>5__2[<i>5__3].opcode == OpCodes.Call)
					{
						object operand = <instructions>5__2[<i>5__3].operand;
						<method>5__4 = operand as MethodInfo;
						if ((object)<method>5__4 != null)
						{
							Type? declaringType = <method>5__4.DeclaringType;
							if ((object)declaringType == null || !declaringType.IsAssignableFrom(typeof(Player)))
							{
								Type? declaringType2 = <method>5__4.DeclaringType;
								if ((object)declaringType2 == null || !declaringType2.IsAssignableFrom(typeof(ZLog)))
								{
									goto IL_06f0;
								}
							}
							if (<method>5__4.Name != "op_Equality")
							{
								<j>5__5 = ((!<method>5__4.IsStatic) ? (-1) : 0);
								goto IL_060c;
							}
						}
					}
					goto IL_06f0;
					IL_060c:
					if (<j>5__5 < <method>5__4.GetParameters().Length)
					{
						<>2__current = new CodeInstruction(OpCodes.Pop, (object)null);
						<>1__state = 16;
						return true;
					}
					if (<method>5__4.ReturnType != typeof(void))
					{
						if (<method>5__4.ReturnType == typeof(float))
						{
							<>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)0f);
							<>1__state = 17;
							return true;
						}
						if (<method>5__4.ReturnType == typeof(int))
						{
							<>2__current = new CodeInstruction(OpCodes.Ldc_I4_0, (object)null);
							<>1__state = 18;
							return true;
						}
						<>2__current = new CodeInstruction(OpCodes.Ldnull, (object)null);
						<>1__state = 19;
						return true;
					}
					goto IL_071f;
					IL_06f0:
					<>2__current = <instructions>5__2[<i>5__3];
					<>1__state = 20;
					return true;
					IL_071f:
					num = <i>5__3 + 1;
					<i>5__3 = num;
					goto IL_072f;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
			{
				<PlayerProfileConsumeUntil>d__22 <PlayerProfileConsumeUntil>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<PlayerProfileConsumeUntil>d__ = this;
				}
				else
				{
					<PlayerProfileConsumeUntil>d__ = new <PlayerProfileConsumeUntil>d__22(0);
				}
				<PlayerProfileConsumeUntil>d__.ilGenerator = <>3__ilGenerator;
				<PlayerProfileConsumeUntil>d__.endOperand = <>3__endOperand;
				return <PlayerProfileConsumeUntil>d__;
			}

			[DebuggerHidden]
			[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
			}
		}

		private static readonly Dictionary<Utils.ProfileName, byte[]> Inventories = new Dictionary<Utils.ProfileName, byte[]>();

		private static readonly Dictionary<ZNetPeer, Utils.ProfileName> peerProfileNameMap = new Dictionary<ZNetPeer, Utils.ProfileName>();

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(2)]
		private static bool isAdmin(ZRpc rpc)
		{
			if (rpc != null)
			{
				return ZNet.instance.ListContainsId(ZNet.instance.m_adminList, rpc.GetSocket().GetHostName());
			}
			return true;
		}

		public static void onGiveItem([<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] ZRpc peerRpc, string itemName, int itemQuantity, string targetPlayerName, string targetPlayerId)
		{
			if (!isAdmin(peerRpc))
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.m_instance.m_peers)
			{
				if (string.Compare(targetPlayerName, peer.m_playerName, StringComparison.InvariantCultureIgnoreCase) == 0 && (targetPlayerId == "0" || Utils.GetPlayerID(peer.m_socket.GetHostName()) == Utils.GetPlayerID(targetPlayerId)))
				{
					peer.m_rpc.Invoke("ServerCharacters GiveItem", new object[2] { itemName, itemQuantity });
					break;
				}
			}
		}

		private static void onGetPlayerPos(ZRpc peerRpc, string targetPlayerName, string targetPlayerId)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			if (!isAdmin(peerRpc))
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.m_instance.m_peers)
			{
				if (string.Compare(targetPlayerName, peer.m_playerName, StringComparison.InvariantCultureIgnoreCase) == 0 && (targetPlayerId == "0" || Utils.GetPlayerID(peer.m_socket.GetHostName()) == Utils.GetPlayerID(targetPlayerId)))
				{
					peerRpc.Invoke("ServerCharacters GetPlayerPos", new object[1] { peer.GetRefPos() });
					return;
				}
			}
			peerRpc.Invoke("ServerCharacters GetPlayerPos", new object[1] { Vector3.zero });
		}

		private static void onSendOwnPos(ZRpc peerRpc, string targetPlayerName, string targetPlayerId, Vector3 pos)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if (!isAdmin(peerRpc))
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.m_instance.m_peers)
			{
				if (string.Compare(targetPlayerName, peer.m_playerName, StringComparison.InvariantCultureIgnoreCase) == 0 && (targetPlayerId == "0" || Utils.GetPlayerID(peer.m_socket.GetHostName()) == Utils.GetPlayerID(targetPlayerId)))
				{
					peer.m_rpc.Invoke("ServerCharacters TeleportTo", new object[1] { pos });
					peerRpc.Invoke("ServerCharacters SendOwnPos", new object[1] { peer.GetRefPos() });
					return;
				}
			}
			peerRpc.Invoke("ServerCharacters SendOwnPos", new object[1] { Vector3.zero });
		}

		public static void onResetSkill([<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] ZRpc peerRpc, string skillName, string targetPlayerName, string targetPlayerId)
		{
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0167: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			if (!isAdmin(peerRpc))
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.m_instance.m_peers)
			{
				if (targetPlayerName == "" || (string.Compare(targetPlayerName, peer.m_playerName, StringComparison.InvariantCultureIgnoreCase) == 0 && (targetPlayerId == "0" || Utils.GetPlayerID(peer.m_socket.GetHostName()) == Utils.GetPlayerID(targetPlayerId))))
				{
					peer.m_rpc.Invoke("ServerCharacters ResetSkill", new object[1] { skillName });
				}
			}
			string[] files = Directory.GetFiles(Utils.CharacterSavePath);
			for (int i = 0; i < files.Length; i++)
			{
				FileInfo fileInfo = new FileInfo(files[i]);
				try
				{
					if (Utils.IsServerCharactersFilePattern(fileInfo.Name))
					{
						string[] array = fileInfo.Name.Split(new char[1] { '_' });
						string text = array[0] + "_" + array[1];
						string strB = array[2].Split(new char[1] { '.' })[0];
						if ((targetPlayerId == "0" || Utils.GetPlayerID(targetPlayerId) == text) && (targetPlayerName == "" || string.Compare(targetPlayerName, strB, StringComparison.InvariantCultureIgnoreCase) == 0))
						{
							PlayerProfile val = new PlayerProfile(fileInfo.Name.Replace(".fch", "") ?? "", (FileSource)1);
							val.LoadPlayerFromDisk();
							Skills obj = ReadSkillsFromProfile(val);
							obj.CheatResetSkill(skillName);
							ZPackage val2 = new ZPackage();
							obj.Save(val2);
							PatchPlayerProfileSkills(val, val2.GetArray());
							val.SavePlayerToDisk();
						}
					}
				}
				catch (Exception arg)
				{
					Utils.Log(string.Format("Removing skill failed for profile {0}: {1}", fileInfo.Name.Replace(".fch", ""), arg));
				}
			}
		}

		public static void onRaiseSkill([<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] ZRpc peerRpc, string skill, int level, string targetPlayerName, string targetPlayerId)
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			if (!isAdmin(peerRpc))
			{
				return;
			}
			foreach (ZNetPeer peer in ZNet.m_instance.m_peers)
			{
				if (targetPlayerName == "" || (string.Compare(targetPlayerName, peer.m_playerName, StringComparison.InvariantCultureIgnoreCase) == 0 && (targetPlayerId == "0" || Utils.GetPlayerID(peer.m_socket.GetHostName()) == Utils.GetPlayerID(targetPlayerId))))
				{
					peer.m_rpc.Invoke("ServerCharacters RaiseSkill", new object[2] { skill, level });
				}
			}
			string[] files = Directory.GetFiles(Utils.CharacterSavePath);
			for (int i = 0; i < files.Length; i++)
			{
				FileInfo fileInfo = new FileInfo(files[i]);
				try
				{
					if (Utils.IsServerCharactersFilePattern(fileInfo.Name))
					{
						string[] array = fileInfo.Name.Split(new char[1] { '_' });
						string text = array[0] + "_" + array[1];
						string strB = array[2].Split(new char[1] { '.' })[0];
						if ((targetPlayerId == "0" || Utils.GetPlayerID(targetPlayerId) == text) && (targetPlayerName == "" || string.Compare(targetPlayerName, strB, StringComparison.InvariantCultureIgnoreCase) == 0))
						{
							PlayerProfile val = new PlayerProfile(fileInfo.Name.Replace(".fch", "") ?? "", (FileSource)1);
							val.LoadPlayerFromDisk();
							Skills obj = ReadSkillsFromProfile(val);
							obj.CheatRaiseSkill(skill, (float)level, true);
							ZPackage val2 = new ZPackage();
							obj.Save(val2);
							PatchPlayerProfileSkills(val, val2.GetArray());
							val.SavePlayerToDisk();
						}
					}
				}
				catch (Exception arg)
				{
					Utils.Log(string.Format("Raise skill failed for profile {0}: {1}", fileInfo.Name.Replace(".fch", ""), arg));
				}
			}
		}

		private static void backupProfile(PlayerProfile profile)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			string text = PlayerProfile.GetCharacterFolderPath(profile.m_fileSource) + profile.m_filename + ".fch.old";
			if (FileHelpers.Exists(text, profile.m_fileSource))
			{
				string characterSavePath = Utils.CharacterSavePath;
				char directorySeparatorChar = Path.DirectorySeparatorChar;
				Directory.CreateDirectory(characterSavePath + directorySeparatorChar + "backups");
				string[] obj = new string[6]
				{
					Utils.CharacterSavePath,
					null,
					null,
					null,
					null,
					null
				};
				directorySeparatorChar = Path.DirectorySeparatorChar;
				obj[1] = directorySeparatorChar.ToString();
				obj[2] = "backups";
				directorySeparatorChar = Path.DirectorySeparatorChar;
				obj[3] = directorySeparatorChar.ToString();
				obj[4] = profile.m_filename;
				obj[5] = ".zip";
				using FileStream stream = new FileStream(string.Concat(obj), FileMode.OpenOrCreate);
				using ZipArchive zipArchive = new ZipArchive(stream, ZipArchiveMode.Update);
				while (zipArchive.Entries.Count >= ServerCharacters.backupsToKeep.Value)
				{
					zipArchive.Entries.First().Delete();
				}
				string text2 = profile.m_filename + "-" + DateTime.Now.ToString("yyyy-MM-ddTHH-mm-ss") + ".fch";
				using Stream destination = zipArchive.CreateEntry(text2).Open();
				FileReader val = new FileReader(text, profile.m_fileSource, (FileHelperType)0);
				(val.m_stream?.BaseStream ?? val.m_binary.BaseStream).CopyTo(destination);
				val.Dispose();
				Utils.Log("Backed up a player profile in '" + text2 + "'");
			}
			string[] array = profile.m_filename.Split(new char[1] { '_' });
			Utils.Cache.profiles[new Utils.ProfileName
			{
				id = ((array.Length > 1) ? (array[0] + "_" + array[1]) : array[0]),
				name = profile.GetName().ToLower()
			}] = profile;
		}

		public static void generateServerKey()
		{
			if (ServerCharacters.serverKey.Value == "")
			{
				byte[] array = new byte[32];
				using RNGCryptoServiceProvider rNGCryptoServiceProvider = new RNGCryptoServiceProvider();
				rNGCryptoServiceProvider.GetBytes(array);
				ServerCharacters.serverKey.Value = Convert.ToBase64String(array);
			}
		}

		private static byte[] ReadInventoryFromProfile(PlayerProfile profile)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage(profile.m_playerData);
			ConsumePlayerSaveUntilInventory(val);
			int pos = val.GetPos();
			new Inventory("Inventory", (Sprite)null, 8, 4).Load(val);
			int pos2 = val.GetPos();
			return profile.m_playerData.Skip(pos).Take(pos2 - pos).ToArray();
		}

		private static void PatchPlayerProfileInventory(PlayerProfile profile, byte[] inventoryData)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage(profile.m_playerData);
			ConsumePlayerSaveUntilInventory(val);
			int pos = val.GetPos();
			new Inventory("Inventory", (Sprite)null, 8, 4).Load(val);
			int pos2 = val.GetPos();
			byte[] array = new byte[pos + (profile.m_playerData.LongLength - pos2) + inventoryData.Length];
			Array.Copy(profile.m_playerData, array, pos);
			Array.Copy(inventoryData, 0, array, pos, inventoryData.Length);
			Array.Copy(profile.m_playerData, pos2, array, pos + inventoryData.Length, profile.m_playerData.LongLength - pos2);
			profile.m_playerData = array;
		}

		private static Skills ReadSkillsFromProfile(PlayerProfile profile)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Expected O, but got Unknown
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected O, but got Unknown
			Skills val = new Skills
			{
				m_skills = ((Component)(Player)Resources.FindObjectsOfTypeAll(typeof(Player))[0]).GetComponent<Skills>().m_skills,
				m_player = (Player)(object)new DummyPlayer()
			};
			ZPackage val2 = new ZPackage(profile.m_playerData);
			ConsumePlayerSaveUntilSkills(val2);
			val.Load(val2);
			return val;
		}

		private static void PatchPlayerProfileSkills(PlayerProfile profile, byte[] skillData)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			ZPackage val = new ZPackage(profile.m_playerData);
			ConsumePlayerSaveUntilSkills(val);
			int pos = val.GetPos();
			new GameObject().AddComponent<Skills>().Load(val);
			int pos2 = val.GetPos();
			byte[] array = new byte[pos + (profile.m_playerData.LongLength - pos2) + skillData.Length];
			Array.Copy(profile.m_playerData, array, pos);
			Array.Copy(skillData, 0, array, pos, skillData.Length);
			Array.Copy(profile.m_playerData, pos2, array, pos + skillData.Length, profile.m_playerData.LongLength - pos2);
			profile.m_playerData = array;
		}

		public static void ConsumePlayerSaveUntilInventory(ZPackage pkg)
		{
			throw new NotImplementedException("Was not patched ...");
		}

		public static void ConsumePlayerSaveUntilSkills(ZPackage pkg)
		{
			throw new NotImplementedException("Was not patched ...");
		}

		[IteratorStateMachine(typeof(<PlayerProfileConsumeUntil>d__22))]
		private static IEnumerable<CodeInstruction> PlayerProfileConsumeUntil(ILGenerator ilGenerator, MethodInfo endOperand)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayerProfileConsumeUntil>d__22(-2)
			{
				<>3__ilGenerator = ilGenerator,
				<>3__endOperand = endOperand
			};
		}
	}
	public static class Shared
	{
		[HarmonyPatch(typeof(Shared), "LoadPlayerProfileFromBytes")]
		private static class LoadPlayerProfileLoader
		{
			[CompilerGenerated]
			private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator
			{
				private int <>1__state;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(1)]
				private CodeInstruction <>2__current;

				private int <>l__initialThreadId;

				private ILGenerator ilGenerator;

				public ILGenerator <>3__ilGenerator;

				[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })]
				private IEnumerable<CodeInstruction> <instructions>5__2;

				private IEnumerator<CodeInstruction> <>7__wrap2;

				CodeInstruction IEnumerator<CodeInstruction>.Current
				{
					[DebuggerHidden]
					[return: <ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(1)]
					get
					{
						return <>2__current;
					}
				}

				object IEnumerator.Current
				{
					[DebuggerHidden]
					get
					{
						return <>2__current;
					}
				}

				[DebuggerHidden]
				public <Transpiler>d__0(int <>1__state)
				{
					this.<>1__state = <>1__state;
					<>l__initialThreadId = Environment.CurrentManagedThreadId;
				}

				[DebuggerHidden]
				void IDisposable.Dispose()
				{
					int num = <>1__state;
					if (num == -3 || num == 3)
					{
						try
						{
						}
						finally
						{
							<>m__Finally1();
						}
					}
					<instructions>5__2 = null;
					<>7__wrap2 = null;
					<>1__state = -2;
				}

				private bool MoveNext()
				{
					//IL_0059: Unknown result type (might be due to invalid IL or missing references)
					//IL_005e: Unknown result type (might be due to invalid IL or missing references)
					//IL_0079: Expected O, but got Unknown
					//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
					//IL_00c1: Expected O, but got Unknown
					try
					{
						switch (<>1__state)
						{
						default:
							return false;
						case 0:
							<>1__state = -1;
							<instructions>5__2 = PatchProcessor.GetOriginalInstructions((MethodBase)AccessTools.DeclaredMethod(typeof(PlayerProfile), "LoadPlayerFromDisk", (Type[])null, (Type[])null), ilGenerator);
							<>2__current = new CodeInstruction(OpCodes.Ldarg_1, (object)null)
							{
								blocks = <instructions>5__2.First().blocks
							};
							<>1__state = 1;
							return true;
						case 1:
							<>1__state = -1;
							<>2__current = new CodeInstruction(OpCodes.Newobj, (object)AccessTools.DeclaredConstructor(typeof(ZPackage), new Type[1] { typeof(byte[]) }, false));
							<>1__state = 2;
							return true;
						case 2:
							<>1__state = -1;
							<>7__wrap2 = <instructions>5__2.Skip(2).GetEnumerator();
							<>1__state = -3;
							break;
						case 3:
							<>1__state = -3;
							break;
						}
						if (<>7__wrap2.MoveNext())
						{
							CodeInstruction current = <>7__wrap2.Current;
							<>2__current = current;
							<>1__state = 3;
							return true;
						}
						<>m__Finally1();
						<>7__wrap2 = null;
						return false;
					}
					catch
					{
						//try-fault
						((IDisposable)this).Dispose();
						throw;
					}
				}

				bool IEnumerator.MoveNext()
				{
					//ILSpy generated this explicit interface implementation from .override directive in MoveNext
					return this.MoveNext();
				}

				private void <>m__Finally1()
				{
					<>1__state = -1;
					if (<>7__wrap2 != null)
					{
						<>7__wrap2.Dispose();
					}
				}

				[DebuggerHidden]
				void IEnumerator.Reset()
				{
					throw new NotSupportedException();
				}

				[DebuggerHidden]
				IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator()
				{
					<Transpiler>d__0 <Transpiler>d__;
					if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
					{
						<>1__state = 0;
						<Transpiler>d__ = this;
					}
					else
					{
						<Transpiler>d__ = new <Transpiler>d__0(0);
					}
					<Transpiler>d__.ilGenerator = <>3__ilGenerator;
					return <Transpiler>d__;
				}

				[DebuggerHidden]
				IEnumerator IEnumerable.GetEnumerator()
				{
					return ((IEnumerable<CodeInstruction>)this).GetEnumerator();
				}
			}

			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			[IteratorStateMachine(typeof(<Transpiler>d__0))]
			[UsedImplicitly]
			private static IEnumerable<CodeInstruction> Transpiler(ILGenerator ilGenerator)
			{
				//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
				return new <Transpiler>d__0(-2)
				{
					<>3__ilGenerator = ilGenerator
				};
			}
		}

		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static class PatchZNetRPC_PeerInfo
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			[HarmonyPriority(0)]
			private static bool Prefix(ZRpc rpc, ref ZPackage pkg)
			{
				pkg.ReadLong();
				string text = pkg.ReadString();
				pkg.SetPos(0);
				if (ZNet.instance.IsServer() && !text.Contains("-ServerCharacters"))
				{
					rpc.Invoke("Error", new object[1] { 3 });
					Utils.Log("Client " + rpc.m_socket.GetHostName() + " tried to connect without having ServerCharacters installed and got disconnected.");
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(GameVersion), "ToString")]
		private static class PatchVersionGetVersionString
		{
			[HarmonyPriority(0)]
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static void Postfix(GameVersion __instance, ref string __result)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				if (__instance == Version.CurrentVersion)
				{
					__result += "-ServerCharacters";
				}
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "Awake")]
		private static class SetAutoSaveInterval
		{
			private static void Postfix()
			{
				Game.m_saveInterval = ServerCharacters.autoSaveInterval.Value * 60;
			}
		}

		[HarmonyPatch(typeof(SaveSystem), "GetSaveInfo")]
		private static class FilterServerCharacterFiles
		{
			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			private static bool Prefix(string path, ref bool __result)
			{
				if (path.EndsWith(".signature", StringComparison.Ordinal) || path.EndsWith(".serverbackup", StringComparison.Ordinal))
				{
					__result = false;
					return false;
				}
				return true;
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass1_0
		{
			public ZNetPeer peer;

			public string eventname;
		}

		[CompilerGenerated]
		private sealed class <sendCompressedDataToPeer>d__1 : IEnumerable<bool>, IEnumerable, IEnumerator<bool>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private bool <>2__current;

			private int <>l__initialThreadId;

			private ZNetPeer peer;

			public ZNetPeer <>3__peer;

			private string eventname;

			public string <>3__eventname;

			private byte[] packageArray;

			public byte[] <>3__packageArray;

			private <>c__DisplayClass1_0 <>8__1;

			private byte[] <data>5__2;

			private int <fragments>5__3;

			private long <packageIdentifier>5__4;

			private int <fragment>5__5;

			private IEnumerator<bool> <>7__wrap5;

			bool IEnumerator<bool>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <sendCompressedDataToPeer>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
				<>l__initialThreadId = Environment.CurrentManagedThreadId;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<>8__1 = null;
				<data>5__2 = null;
				<>7__wrap5 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_014e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0155: Expected O, but got Unknown
				try
				{
					ZPackage val;
					int num;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						<>8__1 = new <>c__DisplayClass1_0();
						<>8__1.peer = peer;
						<>8__1.eventname = eventname;
						MemoryStream memoryStream = new MemoryStream();
						using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Optimal))
						{
							deflateStream.Write(packageArray, 0, packageArray.Length);
						}
						<data>5__2 = memoryStream.ToArray();
						<fragments>5__3 = (int)(1 + (<data>5__2.LongLength - 1) / 250000);
						<packageIdentifier>5__4 = ++packageCounter;
						<fragment>5__5 = 0;
						goto IL_01f1;
					}
					case 1:
						<>1__state = -3;
						goto IL_0116;
					case 2:
						{
							<>1__state = -1;
							goto IL_01df;
						}
						IL_0116:
						if (<>7__wrap5.MoveNext())
						{
							bool current = <>7__wrap5.Current;
							<>2__current = current;
							<>1__state = 1;
							return true;
						}
						<>m__Finally1();
						<>7__wrap5 = null;
						if (!<>8__1.peer.m_socket.IsConnected())
						{
							return false;
						}
						val = new ZPackage();
						val.Write(<packageIdentifier>5__4);
						val.Write(<fragment>5__5);
						val.Write(<fragments>5__3);
						val.Write(<data>5__2.Skip(250000 * <fragment>5__5).Take(250000).ToArray());
						SendPackage(val);
						if (<fragment>5__5 != <fragments>5__3 - 1)
						{
							<>2__current = true;
							<>1__state = 2;
							return true;
						}
						goto IL_01df;
						IL_01f1:
						if (<fragment>5__5 < <fragments>5__3)
						{
							<>7__wrap5 = waitForQueue().GetEnumerator();
							<>1__state = -3;
							goto IL_0116;
						}
						return false;
						IL_01df:
						num = <fragment>5__5 + 1;
						<fragment>5__5 = num;
						goto IL_01f1;
					}
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
				[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
				void SendPackage(ZPackage pkg)
				{
					((<>c__DisplayClass1_0)this).peer.m_rpc.Invoke(((<>c__DisplayClass1_0)this).eventname, new object[1] { pkg });
				}
				[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
				[IteratorStateMachine(typeof(<>c__DisplayClass1_0.<<sendCompressedDataToPeer>g__waitForQueue|0>d))]
				IEnumerable<bool> waitForQueue()
				{
					//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
					return new <>c__DisplayClass1_0.<<sendCompressedDataToPeer>g__waitForQueue|0>d(-2)
					{
						<>4__this = this
					};
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				if (<>7__wrap5 != null)
				{
					<>7__wrap5.Dispose();
				}
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}

			[DebuggerHidden]
			IEnumerator<bool> IEnumerable<bool>.GetEnumerator()
			{
				<sendCompressedDataToPeer>d__1 <sendCompressedDataToPeer>d__;
				if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId)
				{
					<>1__state = 0;
					<sendCompressedDataToPeer>d__ = this;
				}
				else
				{
					<sendCompressedDataToPeer>d__ = new <sendCompressedDataToPeer>d__1(0);
				}
				<sendCompressedDataToPeer>d__.peer = <>3__peer;
				<sendCompressedDataToPeer>d__.eventname = <>3__eventname;
				<sendCompressedDataToPeer>d__.packageArray = <>3__packageArray;
				return <sendCompressedDataToPeer>d__;
			}

			[DebuggerHidden]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return ((IEnumerable<bool>)this).GetEnumerator();
			}
		}

		private static long packageCounter = 1L;

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(1)]
		private static readonly Dictionary<string, SortedDictionary<int, byte[]>> profileCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 1, 0, 1 })]
		private static readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		[IteratorStateMachine(typeof(<sendCompressedDataToPeer>d__1))]
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		public static IEnumerable<bool> sendCompressedDataToPeer(ZNetPeer peer, string eventname, byte[] packageArray)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <sendCompressedDataToPeer>d__1(-2)
			{
				<>3__peer = peer,
				<>3__eventname = eventname,
				<>3__packageArray = packageArray
			};
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		public static Action<ZRpc, ZPackage> receiveCompressedFromPeer(Action<ZRpc, byte[]> onReceived)
		{
			return [<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)] (ZRpc sender, ZPackage package) =>
			{
				cacheExpirations.RemoveAll(([<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						profileCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				long num = package.ReadLong();
				string text = ((object)sender).ToString() + num;
				if (!profileCache.TryGetValue(text, out var value))
				{
					value = new SortedDictionary<int, byte[]>();
					profileCache[text] = value;
					cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text));
				}
				int key = package.ReadInt();
				int num2 = package.ReadInt();
				value.Add(key, package.ReadByteArray());
				if (value.Count < num2)
				{
					Utils.Log($"Received incomplete data from peer {Utils.GetPlayerID(sender.GetSocket().GetHostName())} - fragments {num2}, received {value.Count}");
				}
				else
				{
					profileCache.Remove(text);
					MemoryStream stream = new MemoryStream(value.Values.SelectMany((byte[] a) => a).ToArray());
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					byte[] arg = memoryStream.ToArray();
					onReceived(sender, arg);
				}
			};
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		public static bool LoadPlayerProfileFromBytes(this PlayerProfile profile, byte[] data)
		{
			throw new NotImplementedException("Was not patched ...");
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
		public static bool CharacterNameIsForbidden(string characterName)
		{
			if (characterName.Length >= 3)
			{
				return characterName.Any((char c) => c != ' ' && c != '\'' && !char.IsLetter(c));
			}
			return true;
		}
	}
	[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
	[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
	public static class Utils
	{
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		public record struct ProfileName
		{
			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(1)]
			[UsedImplicitly]
			public string id;

			[UsedImplicitly]
			[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(1)]
			public string name;

			[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
			public static ProfileName fromPeer(ZNetPeer peer)
			{
				ProfileName result = default(ProfileName);
				result.id = GetPlayerID(peer.m_socket.GetHostName());
				result.name = peer.m_playerName;
				return result;
			}
		}

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		public static class Cache
		{
			public static readonly Dictionary<ProfileName, PlayerProfile> profiles = new Dictionary<ProfileName, PlayerProfile>();

			public static PlayerProfile loadProfile(ProfileName name)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Expected O, but got Unknown
				if (!profiles.TryGetValue(name, out var value))
				{
					value = new PlayerProfile(name.id + "_" + name.name, (FileSource)1);
					value.LoadPlayerFromDisk();
					profiles[name] = value;
				}
				return value;
			}
		}

		public static string CharacterSavePath => PlayerProfile.GetCharacterFolderPath((FileSource)1);

		public static bool GetToggle(this ConfigEntry<Toggle> toggle)
		{
			return toggle.Value == Toggle.On;
		}

		public static string getHumanFriendlyTime(int seconds)
		{
			TimeSpan timeSpan = TimeSpan.FromSeconds(seconds);
			return ((timeSpan.TotalMinutes >= 1.0) ? ($"{(int)timeSpan.TotalMinutes} minute" + ((timeSpan.TotalMinutes >= 2.0) ? "s" : "") + ((timeSpan.Seconds != 0) ? " and " : "")) : "") + ((timeSpan.Seconds != 0) ? ($"{timeSpan.Seconds} second" + ((timeSpan.Seconds >= 2) ? "s" : "")) : "");
		}

		public static void PostToDiscord(string content, string username)
		{
			if (content == "" || ServerCharacters.webhookURL.Value == "")
			{
				return;
			}
			WebRequest discordAPI = WebRequest.Create(ServerCharacters.webhookURL.Value);
			discordAPI.Method = "POST";
			discordAPI.ContentType = "application/json";
			discordAPI.GetRequestStreamAsync().ContinueWith([<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)] (Task<Stream> t) =>
			{
				using StreamWriter streamWriter = new StreamWriter(t.Result);
				string value = "{\"content\":\"" + escape(content) + "\"" + ((username == "") ? "" : (", \"username\":\"" + escape(username) + "\"")) + "}";
				streamWriter.WriteAsync(value).ContinueWith([<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)] (Task _) => discordAPI.GetResponseAsync());
			});
			static string escape(string s)
			{
				return s.Replace("\\", "\\\\").Replace("\"", "\\\"");
			}
		}

		public static void Log(string message)
		{
			ServerCharacters.logger.LogMessage((object)message);
		}

		public static bool IsServerCharactersFilePattern(string file)
		{
			if (file.Split(new char[1] { '_' }).Length >= 3 && file.EndsWith(".fch", StringComparison.Ordinal))
			{
				return !file.Contains("_backup_");
			}
			return false;
		}

		public static PlayerList GetPlayerListFromFiles()
		{
			//IL_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			PlayerList playerList = new PlayerList();
			Dictionary<ProfileName, PlayerInfo> dictionary = ZNet.m_instance.m_players.ToDictionary(delegate(PlayerInfo p)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				ProfileName result = default(ProfileName);
				result.id = GetPlayerID(((object)(PlatformUserID)(ref p.m_userInfo.m_id)).ToString());
				result.name = p.m_name.ToLower();
				return result;
			}, (PlayerInfo p) => p);
			string[] files = Directory.GetFiles(CharacterSavePath);
			for (int i = 0; i < files.Length; i++)
			{
				FileInfo fileInfo = new FileInfo(files[i]);
				if (!IsServerCharactersFilePattern(fileInfo.Name))
				{
					continue;
				}
				WebinterfacePlayer webinterfacePlayer = new WebinterfacePlayer();
				string[] array = fileInfo.Name.Split(new char[1] { '_' });
				webinterfacePlayer.Id = array[0] + "_" + array[1];
				webinterfacePlayer.Name = array[2].Split(new char[1] { '.' })[0];
				ProfileName profileName = default(ProfileName);
				profileName.id = webinterfacePlayer.Id;
				profileName.name = webinterfacePlayer.Name;
				ProfileName profileName2 = profileName;
				PlayerInfo value;
				bool flag = dictionary.TryGetValue(profileName2, out value);
				PlayerProfile val = Cache.loadProfile(profileName2);
				webinterfacePlayer.statistics = new WebinterfacePlayer.Statistics
				{
					lastTouch = (flag ? 0 : ((DateTimeOffset)fileInfo.LastWriteTimeUtc).ToUnixTimeSeconds())
				};
				foreach (KeyValuePair<PlayerStatType, float> stat in val.m_playerStats.m_stats)
				{
					Dictionary<string, float> stats = webinterfacePlayer.statistics.Stats;
					PlayerStatType key = stat.Key;
					stats[((object)(PlayerStatType)(ref key)).ToString()] = stat.Value;
				}
				Vector3 val2 = ((!flag) ? val.GetLogoutPoint() : (ZNet.instance.GetPeerByHostName(((object)(PlatformUserID)(ref value.m_userInfo.m_id)).ToString())?.m_refPos ?? val.GetLogoutPoint()));
				webinterfacePlayer.position = new WebinterfacePlayer.Position
				{
					X = val2.x,
					Y = val2.y,
					Z = val2.z
				};
				playerList.playerLists.Add(webinterfacePlayer);
			}
			return playerList;
		}

		public static string GetPlayerID(string player)
		{
			if (Regex.IsMatch(player, "^\\d+$"))
			{
				player = "Steam_" + player;
			}
			return player;
		}

		public static void OverwriteDict<[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] K, [<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] V>(IDictionary<K, V> src, IDictionary<K, V> dst)
		{
			dst.Clear();
			foreach (KeyValuePair<K, V> item in src)
			{
				dst.Add(item.Key, item.Value);
			}
		}
	}
	[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(1)]
	[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
	public static class WebInterfaceAPI
	{
		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)]
		[HarmonyPatch(typeof(ZNet), "SetServer")]
		private static class Patch_ZNet_SetServer
		{
			private static void Postfix()
			{
				if (serverConfig != null)
				{
					serverConfig.serverName = ZNet.m_ServerName;
					Broadcast("ServerConfig", serverConfig);
				}
			}
		}

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(0)]
		private class Command
		{
			public static PlayerList GetPlayerList()
			{
				return ExecuteOnMain((Func<PlayerList>)Utils.GetPlayerListFromFiles);
			}

			public static ModList GetModList()
			{
				ModList modList = new ModList();
				modList.modLists.AddRange(Chainloader.PluginInfos.Values.Select([<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)] (PluginInfo plugin) =>
				{
					WebinterfaceMod obj = new WebinterfaceMod
					{
						Guid = plugin.Metadata.GUID,
						Name = plugin.Metadata.Name,
						Version = plugin.Metadata.Version.ToString(),
						lastUpdate = ((DateTimeOffset)File.GetLastWriteTime(plugin.Location)).ToUnixTimeSeconds()
					};
					string location = plugin.Location;
					string pluginPath = Paths.PluginPath;
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					obj.modPath = location.Replace(pluginPath + directorySeparatorChar, "");
					object configPath;
					if (!Object.op_Implicit((Object)(object)plugin.Instance))
					{
						configPath = "";
					}
					else
					{
						string configFilePath = plugin.Instance.Config.ConfigFilePath;
						string configPath2 = Paths.ConfigPath;
						directorySeparatorChar = Path.DirectorySeparatorChar;
						configPath = configFilePath.Replace(configPath2 + directorySeparatorChar, "");
					}
					obj.configPath = (string)configPath;
					return obj;
				}));
				return modList;
			}

			public static void SendIngameMessage(IngameMessage message)
			{
				ExecuteOnMain(delegate
				{
					IEnumerable<ZNetPeer> enumerable;
					if (message.steamIds.Count != 0)
					{
						enumerable = ((IEnumerable<string>)message.steamIds).Select((Func<string, ZNetPeer>)([<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)] (string id) =>
						{
							ZNetPeer peerByHostName = ZNet.instance.GetPeerByHostName(id);
							if (peerByHostName == null)
							{
								if (!id.StartsWith("Steam_"))
								{
									return null;
								}
								peerByHostName = ZNet.instance.GetPeerByHostName(id.Substring(6));
							}
							return peerByHostName;
						}));
					}
					else
					{
						IEnumerable<ZNetPeer> peers = ZNet.instance.m_peers;
						enumerable = peers;
					}
					foreach (ZNetPeer item in enumerable)
					{
						if (item != null)
						{
							item.m_rpc.Invoke("ServerCharacters IngameMessage", new object[1] { message.Message });
						}
					}
				});
			}

			public static void KickPlayer(IngameMessage message)
			{
				ExecuteOnMain(delegate
				{
					IEnumerable<ZNetPeer> enumerable;
					if (message.steamIds.Count != 0)
					{
						enumerable = ((IEnumerable<string>)message.steamIds).Select((Func<string, ZNetPeer>)([<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(0)] (string id) =>
						{
							ZNetPeer peerByHostName = ZNet.instance.GetPeerByHostName(id);
							if (peerByHostName == null)
							{
								if (!id.StartsWith("Steam_"))
								{
									return null;
								}
								peerByHostName = ZNet.instance.GetPeerByHostName(id.Substring(6));
							}
							return peerByHostName;
						}));
					}
					else
					{
						IEnumerable<ZNetPeer> peers = ZNet.instance.m_peers;
						enumerable = peers;
					}
					foreach (ZNetPeer item in enumerable)
					{
						if (item != null)
						{
							item.m_rpc.Invoke("ServerCharacters KickMessage", new object[1] { message.Message });
							ZNet.instance.Disconnect(item);
						}
					}
				});
			}

			public static void SaveWorld()
			{
				ExecuteOnMain(delegate
				{
					ZNet.instance.SaveWorldAndPlayerProfiles();
				});
			}

			public static void RaiseSkill(RaiseSkill data)
			{
				ExecuteOnMain(delegate
				{
					ServerSide.onRaiseSkill(null, data.skillName, data.Level, data.Name ?? "", data.Id ?? "0");
				});
			}

			public static void ResetSkill(RaiseSkill data)
			{
				ExecuteOnMain(delegate
				{
					ServerSide.onResetSkill(null, data.skillName, data.Name ?? "", data.Id ?? "0");
				});
			}

			public static void GiveItem(GiveItem data)
			{
				ExecuteOnMain(delegate
				{
					ServerSide.onGiveItem(null, data.itemName, data.itemQuantity, data.Name, data.Id ?? "0");
				});
			}
		}

		[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)]
		private static ServerConfig serverConfig;

		private static readonly HashSet<TcpClient> clients = new HashSet<TcpClient>();

		public static void StartServer()
		{
			serverConfig = new ServerConfig
			{
				configPath = Paths.ConfigPath,
				pluginsPath = Paths.PluginPath,
				patchersPath = Paths.PatcherPluginPath,
				savePath = Utils.GetSaveDataPath((FileSource)1),
				processId = Process.GetCurrentProcess().Id,
				serverName = ZNet.m_ServerName
			};
			new Thread(Server).Start();
		}

		private static async void Server()
		{
			try
			{
				Uri.TryCreate("tcp://" + ServerCharacters.serverListenAddress.Value, UriKind.Absolute, out Uri result);
				TcpListener listener = new TcpListener(IPAddress.Parse(result.Host), result.Port);
				listener.Start();
				while (true)
				{
					ProcessClientRequest(await listener.AcceptTcpClientAsync());
				}
			}
			catch (Exception ex)
			{
				Debug.LogError((object)("WebInterfaceAPI threw: " + ex));
			}
		}

		private static void Broadcast(string command, IExtensible message)
		{
			foreach (TcpClient client in clients)
			{
				SendMessage(client, command, message);
			}
		}

		private static async void ProcessClientRequest(TcpClient client)
		{
			NetworkStream data = client.GetStream();
			clients.Add(client);
			SendMessage(client, "ServerConfig", serverConfig);
			SendMessage(client, "MaintenanceMessage", new Maintenance
			{
				maintenanceActive = (ServerCharacters.maintenanceMode.GetToggle() && ServerCharacters.selfReference.tickCount > 1073741823),
				startTime = (ServerCharacters.maintenanceMode.GetToggle() ? (DateTimeOffset.Now.ToUnixTimeSeconds() + ServerCharacters.selfReference.tickCount) : 0)
			});
			SendMessage(client, "Ready", null);
			while (true)
			{
				byte[] packageLenBuf = new byte[4];
				try
				{
					_ = 1;
					byte[] packet;
					try
					{
						int num;
						for (int read2 = 0; read2 < 4; read2 += num)
						{
							num = await data.ReadAsync(packageLenBuf, read2, 4 - read2);
							if (num <= 0)
							{
								break;
							}
						}
						int packageLen = BitConverter.ToInt32(packageLenBuf, 0);
						packet = new byte[packageLen];
						int num2;
						for (int read2 = 0; read2 < packageLen; read2 += num2)
						{
							num2 = await data.ReadAsync(packet, read2, packageLen - read2);
							if (num2 <= 0)
							{
								break;
							}
						}
					}
					catch (IOException)
					{
						goto end_IL_00de;
					}
					if (packet.Length < 8)
					{
						break;
					}
					ProcessPacket(client, packet);
					continue;
					end_IL_00de:;
				}
				catch (Exception ex2)
				{
					await Console.Error.WriteAsync("WAPI: " + ex2);
				}
				break;
			}
			clients.Remove(client);
		}

		[<17692631-e0d9-4bdb-8b7e-e1cff9bf39d5>NullableContext(2)]
		private static void SendMessage([<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(1)] TcpClient client, string command, IExtensible msg, int packetKey = 0)
		{
			MemoryStream memoryStream = new MemoryStream();
			memoryStream.Write(BitConverter.GetBytes(packetKey), 0, 4);
			if (packetKey == 0)
			{
				byte[] bytes = Encoding.UTF8.GetBytes(command);
				memoryStream.Write(BitConverter.GetBytes(bytes.Length), 0, 4);
				memoryStream.Write(bytes, 0, bytes.Length);
			}
			MemoryStream memoryStream2 = new MemoryStream();
			if (msg != null)
			{
				ProtoBuf.Serializer.Serialize(memoryStream2, msg);
			}
			memoryStream.Write(BitConverter.GetBytes((int)memoryStream2.Length), 0, 4);
			memoryStream.Write(memoryStream2.ToArray(), 0, (int)memoryStream2.Length);
			MemoryStream memoryStream3 = new MemoryStream();
			memoryStream3.Write(BitConverter.GetBytes((int)memoryStream.Length), 0, 4);
			memoryStream3.Write(memoryStream.ToArray(), 0, (int)memoryStream.Length);
			client.GetStream().Write(memoryStream3.ToArray(), 0, (int)memoryStream3.Length);
		}

		private static void ProcessPacket(TcpClient client, byte[] packet)
		{
			int packetKey = BitConverter.ToInt32(packet, 0);
			int num = BitConverter.ToInt32(packet, 4);
			string @string = Encoding.UTF8.GetString(packet, 8, num);
			int count = BitConverter.ToInt32(packet, 8 + num);
			MemoryStream source = new MemoryStream(packet, 12 + num, count);
			Console.Error.Write("WAPI got command: " + @string);
			MethodInfo method = typeof(Command).GetMethod(@string);
			if ((object)method != null)
			{
				Console.Error.Write("WAPI processing command: " + method);
				ParameterInfo[] parameters = method.GetParameters();
				object[] parameters2 = Array.Empty<object>();
				if (parameters.Length != 0)
				{
					parameters2 = new object[1] { ProtoBuf.Serializer.Deserialize(parameters[0].ParameterType, source) };
				}
				object obj = method.Invoke(null, parameters2);
				SendMessage(client, null, (IExtensible)obj, packetKey);
			}
		}

		public static void SendMaintenanceMessage(Maintenance message)
		{
			Broadcast("MaintenanceMessage", message);
		}

		private static void ExecuteOnMain(Action action)
		{
			ThreadingHelper.SynchronizingObject.Invoke(action, Array.Empty<object>());
		}

		private static T ExecuteOnMain<[<ac6d2775-cef6-4d66-9819-032e899cd913>Nullable(2)] T>(Func<T> action)
		{
			return (T)ThreadingHelper.SynchronizingObject.Invoke(action, Array.Empty<object>());
		}
	}
	[ProtoContract]
	public class WebinterfacePlayer : IExtensible
	{
		[ProtoContract]
		public class Statistics : IExtensible
		{
			private IExtension __pbn__extensionData;

			[ProtoMember(1)]
			public long lastTouch { get; set; }

			[ProtoMap]
			[ProtoMember(6, Name = "stats")]
			public Dictionary<string, float> Stats { get; } = new Dictionary<string, float>();


			IExtension IExtensible.GetExtensionObject(bool createIfMissing)
			{
				return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
			}
		}

		[ProtoContract]
		public class Position : IExtensible
		{
			private IExtension __pbn__extensionData;

			[ProtoMember(1, Name = "x")]
			public float X { get; set; }

			[ProtoMember(2, Name = "y")]
			public float Y { get; set; }

			[ProtoMember(3, Name = "z")]
			public float Z { get; set; }

			IExtension IExtensible.GetExtensionObject(bool createIfMissing)
			{
				return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
			}
		}

		private IExtension __pbn__extensionData;

		[DefaultValue("")]
		[ProtoMember(1, Name = "id")]
		public string Id { get; set; } = "";


		[ProtoMember(2, Name = "name")]
		[DefaultValue("")]
		public string Name { get; set; } = "";


		[ProtoMember(3)]
		public Statistics statistics { get; set; }

		[ProtoMember(4)]
		public Position position { get; set; }

		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class PlayerList : IExtensible
	{
		private IExtension __pbn__extensionData;

		[ProtoMember(1, Name = "playerList")]
		public List<WebinterfacePlayer> playerLists { get; } = new List<WebinterfacePlayer>();


		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class WebinterfaceMod : IExtensible
	{
		private IExtension __pbn__extensionData;

		[DefaultValue("")]
		[ProtoMember(1, Name = "guid")]
		public string Guid { get; set; } = "";


		[ProtoMember(2, Name = "name")]
		[DefaultValue("")]
		public string Name { get; set; } = "";


		[ProtoMember(3, Name = "version")]
		[DefaultValue("")]
		public string Version { get; set; } = "";


		[ProtoMember(4)]
		public long lastUpdate { get; set; }

		[ProtoMember(5)]
		[DefaultValue("")]
		public string modPath { get; set; } = "";


		[ProtoMember(6)]
		[DefaultValue("")]
		public string configPath { get; set; } = "";


		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class ModList : IExtensible
	{
		private IExtension __pbn__extensionData;

		[ProtoMember(1, Name = "modList")]
		public List<WebinterfaceMod> modLists { get; } = new List<WebinterfaceMod>();


		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class ServerConfig : IExtensible
	{
		private IExtension __pbn__extensionData;

		[DefaultValue("")]
		[ProtoMember(1)]
		public string serverName { get; set; } = "";


		[ProtoMember(2)]
		public int processId { get; set; }

		[ProtoMember(3)]
		[DefaultValue("")]
		public string pluginsPath { get; set; } = "";


		[DefaultValue("")]
		[ProtoMember(4)]
		public string patchersPath { get; set; } = "";


		[ProtoMember(5)]
		[DefaultValue("")]
		public string configPath { get; set; } = "";


		[DefaultValue("")]
		[ProtoMember(6)]
		public string savePath { get; set; } = "";


		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class Maintenance : IExtensible
	{
		private IExtension __pbn__extensionData;

		[ProtoMember(1)]
		public long startTime { get; set; }

		[ProtoMember(2)]
		public bool maintenanceActive { get; set; }

		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class IngameMessage : IExtensible
	{
		private IExtension __pbn__extensionData;

		[ProtoMember(1, Name = "steamId")]
		public List<string> steamIds { get; } = new List<string>();


		[DefaultValue("")]
		[ProtoMember(2, Name = "message")]
		public string Message { get; set; } = "";


		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class RaiseSkill : IExtensible
	{
		private IExtension __pbn__extensionData;

		[DefaultValue("")]
		[ProtoMember(1, Name = "id")]
		public string Id { get; set; } = "";


		[ProtoMember(2, Name = "name")]
		[DefaultValue("")]
		public string Name { get; set; } = "";


		[ProtoMember(3)]
		[DefaultValue("")]
		public string skillName { get; set; } = "";


		[ProtoMember(4, Name = "level")]
		public int Level { get; set; }

		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class ResetSkill : IExtensible
	{
		private IExtension __pbn__extensionData;

		[DefaultValue("")]
		[ProtoMember(1, Name = "id")]
		public string Id { get; set; } = "";


		[ProtoMember(2, Name = "name")]
		[DefaultValue("")]
		public string Name { get; set; } = "";


		[DefaultValue("")]
		[ProtoMember(3)]
		public string skillName { get; set; } = "";


		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
	[ProtoContract]
	public class GiveItem : IExtensible
	{
		private IExtension __pbn__extensionData;

		[ProtoMember(1, Name = "id")]
		[DefaultValue("")]
		public string Id { get; set; } = "";


		[ProtoMember(2, Name = "name")]
		[DefaultValue("")]
		public string Name { get; set; } = "";


		[ProtoMember(3)]
		[DefaultValue("")]
		public string itemName { get; set; } = "";


		[ProtoMember(4)]
		public int itemQuantity { get; set; }

		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return Extensible.GetExtensionObject(ref __pbn__extensionData, createIfMissing);
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<a8285431-8789-4c16-acea-9835185d6192>Embedded]
	[CompilerGenerated]
	internal sealed class <a8285431-8789-4c16-acea-9835185d6192>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[<a8285431-8789-4c16-acea-9835185d6192>Embedded]
	internal sealed class <052f11ca-9939-4995-81e6-8224eafe9595>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <052f11ca-9939-4995-81e6-8224eafe9595>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <052f11ca-9939-4995-81e6-8224eafe9595>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[<a8285431-8789-4c16-acea-9835185d6192>Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[<a8285431-8789-4c16-acea-9835185d6192>Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ServerSync
{
	[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
	[PublicAPI]
	[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
	internal abstract class OwnConfigEntryBase
	{
		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		public object LocalBaseValue;

		public bool SynchronizedConfig = true;

		public abstract ConfigEntryBase BaseConfig { get; }
	}
	[PublicAPI]
	[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
	[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
	internal class SyncedConfigEntry<[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)] T> : OwnConfigEntryBase
	{
		public readonly ConfigEntry<T> SourceConfig;

		public override ConfigEntryBase BaseConfig => (ConfigEntryBase)(object)SourceConfig;

		public T Value
		{
			get
			{
				return SourceConfig.Value;
			}
			set
			{
				SourceConfig.Value = value;
			}
		}

		public SyncedConfigEntry(ConfigEntry<T> sourceConfig)
		{
			SourceConfig = sourceConfig;
			base..ctor();
		}

		public void AssignLocalValue(T value)
		{
			if (LocalBaseValue == null)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
	[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(2)]
	internal abstract class CustomSyncedValueBase
	{
		public object LocalBaseValue;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(1)]
		public readonly string Identifier;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(1)]
		public readonly Type Type;

		private object boxedValue;

		protected bool localIsOwner;

		public readonly int Priority;

		public object BoxedValue
		{
			get
			{
				return boxedValue;
			}
			set
			{
				boxedValue = value;
				this.ValueChanged?.Invoke();
			}
		}

		public event Action ValueChanged;

		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
		protected CustomSyncedValueBase(ConfigSync configSync, string identifier, Type type, int priority)
		{
			Priority = priority;
			Identifier = identifier;
			Type = type;
			configSync.AddCustomValue(this);
			localIsOwner = configSync.IsSourceOfTruth;
			configSync.SourceOfTruthChanged += delegate(bool truth)
			{
				localIsOwner = truth;
			};
		}
	}
	[PublicAPI]
	[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
	[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
	internal sealed class CustomSyncedValue<[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)] T> : CustomSyncedValueBase
	{
		public T Value
		{
			get
			{
				return (T)base.BoxedValue;
			}
			set
			{
				base.BoxedValue = value;
			}
		}

		public CustomSyncedValue(ConfigSync configSync, string identifier, T value = default(T), int priority = 0)
			: base(configSync, identifier, typeof(T), priority)
		{
			Value = value;
		}

		public void AssignLocalValue(T value)
		{
			if (localIsOwner)
			{
				Value = value;
			}
			else
			{
				LocalBaseValue = value;
			}
		}
	}
	internal class ConfigurationManagerAttributes
	{
		[UsedImplicitly]
		public bool? ReadOnly = false;
	}
	[PublicAPI]
	[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
	[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
	internal class ConfigSync
	{
		[HarmonyPatch(typeof(ZRpc), "HandlePackage")]
		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)]
		private static class SnatchCurrentlyHandlingRPC
		{
			[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
			public static ZRpc currentRpc;

			[HarmonyPrefix]
			[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
			private static void Prefix(ZRpc __instance)
			{
				currentRpc = __instance;
			}
		}

		[HarmonyPatch(typeof(ZNet), "Awake")]
		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)]
		internal static class RegisterRPCPatch
		{
			[HarmonyPostfix]
			[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
			private static void Postfix(ZNet __instance)
			{
				isServer = __instance.IsServer();
				foreach (ConfigSync configSync2 in configSyncs)
				{
					ZRoutedRpc.instance.Register<ZPackage>(configSync2.Name + " ConfigSync", (Action<long, ZPackage>)configSync2.RPC_FromOtherClientConfigSync);
					if (isServer)
					{
						configSync2.InitialSyncDone = true;
						Debug.Log((object)("Registered '" + configSync2.Name + " ConfigSync' RPC - waiting for incoming connections"));
					}
				}
				if (isServer)
				{
					((MonoBehaviour)__instance).StartCoroutine(WatchAdminListChanges());
				}
				[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
				static void SendAdmin(List<ZNetPeer> peers, bool isAdmin)
				{
					ZPackage package = ConfigsToPackage(null, null, new PackageEntry[1]
					{
						new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = isAdmin
						}
					});
					ConfigSync configSync = configSyncs.First();
					if (configSync != null)
					{
						((MonoBehaviour)ZNet.instance).StartCoroutine(configSync.sendZPackage(peers, package));
					}
				}
				[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
				static IEnumerator WatchAdminListChanges()
				{
					MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
					SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
					List<string> CurrentList = new List<string>(adminList.GetList());
					while (true)
					{
						yield return (object)new WaitForSeconds(30f);
						if (!adminList.GetList().SequenceEqual(CurrentList))
						{
							CurrentList = new List<string>(adminList.GetList());
							List<ZNetPeer> adminPeer = ZNet.instance.GetPeers().Where(delegate(ZNetPeer p)
							{
								string hostName = p.m_rpc.GetSocket().GetHostName();
								return ((object)listContainsId == null) ? adminList.Contains(hostName) : ((bool)listContainsId.Invoke(ZNet.instance, new object[2] { adminList, hostName }));
							}).ToList();
							List<ZNetPeer> nonAdminPeer = ZNet.instance.GetPeers().Except(adminPeer).ToList();
							SendAdmin(nonAdminPeer, isAdmin: false);
							SendAdmin(adminPeer, isAdmin: true);
						}
					}
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)]
		private static class RegisterClientRPCPatch
		{
			[HarmonyPostfix]
			[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
			private static void Postfix(ZNet __instance, ZNetPeer peer)
			{
				if (__instance.IsServer())
				{
					return;
				}
				foreach (ConfigSync configSync in configSyncs)
				{
					peer.m_rpc.Register<ZPackage>(configSync.Name + " ConfigSync", (Action<ZRpc, ZPackage>)configSync.RPC_FromServerConfigSync);
				}
			}
		}

		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)]
		private class ParsedConfigs
		{
			[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<OwnConfigEntryBase, object> configValues = new Dictionary<OwnConfigEntryBase, object>();

			[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 1, 1, 2 })]
			public readonly Dictionary<CustomSyncedValueBase, object> customValues = new Dictionary<CustomSyncedValueBase, object>();
		}

		[HarmonyPatch(typeof(ZNet), "Shutdown")]
		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)]
		private class ResetConfigsOnShutdown
		{
			[HarmonyPostfix]
			private static void Postfix()
			{
				ProcessingServerUpdate = true;
				foreach (ConfigSync configSync in configSyncs)
				{
					configSync.resetConfigsFromServer();
					configSync.IsSourceOfTruth = true;
					configSync.InitialSyncDone = false;
				}
				ProcessingServerUpdate = false;
			}
		}

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private class SendConfigsAfterLogin
		{
			[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
			private class BufferingSocket : ZPlayFabSocket, ISocket
			{
				public volatile bool finished = false;

				public volatile int versionMatchQueued = -1;

				public readonly List<ZPackage> Package = new List<ZPackage>();

				public readonly ISocket Original;

				public BufferingSocket(ISocket original)
				{
					Original = original;
					((ZPlayFabSocket)this)..ctor();
				}

				public bool IsConnected()
				{
					return Original.IsConnected();
				}

				public ZPackage Recv()
				{
					return Original.Recv();
				}

				public int GetSendQueueSize()
				{
					return Original.GetSendQueueSize();
				}

				public int GetCurrentSendRate()
				{
					return Original.GetCurrentSendRate();
				}

				public bool IsHost()
				{
					return Original.IsHost();
				}

				public void Dispose()
				{
					Original.Dispose();
				}

				public bool GotNewData()
				{
					return Original.GotNewData();
				}

				public void Close()
				{
					Original.Close();
				}

				public string GetEndPointString()
				{
					return Original.GetEndPointString();
				}

				public void GetAndResetStats(out int totalSent, out int totalRecv)
				{
					Original.GetAndResetStats(ref totalSent, ref totalRecv);
				}

				public void GetConnectionQuality(out float localQuality, out float remoteQuality, out int ping, out float outByteSec, out float inByteSec)
				{
					Original.GetConnectionQuality(ref localQuality, ref remoteQuality, ref ping, ref outByteSec, ref inByteSec);
				}

				public ISocket Accept()
				{
					return Original.Accept();
				}

				public int GetHostPort()
				{
					return Original.GetHostPort();
				}

				public bool Flush()
				{
					return Original.Flush();
				}

				public string GetHostName()
				{
					return Original.GetHostName();
				}

				public void VersionMatch()
				{
					if (finished)
					{
						Original.VersionMatch();
					}
					else
					{
						versionMatchQueued = Package.Count;
					}
				}

				public void Send(ZPackage pkg)
				{
					//IL_0057: Unknown result type (might be due to invalid IL or missing references)
					//IL_005d: Expected O, but got Unknown
					int pos = pkg.GetPos();
					pkg.SetPos(0);
					int num = pkg.ReadInt();
					if ((num == StringExtensionMethods.GetStableHashCode("PeerInfo") || num == StringExtensionMethods.GetStableHashCode("RoutedRPC") || num == StringExtensionMethods.GetStableHashCode("ZDOData")) && !finished)
					{
						ZPackage val = new ZPackage(pkg.GetArray());
						val.SetPos(pos);
						Package.Add(val);
					}
					else
					{
						pkg.SetPos(pos);
						Original.Send(pkg);
					}
				}
			}

			[HarmonyPrefix]
			[HarmonyPriority(800)]
			private static void Prefix([<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 2, 1, 1 })] ref Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				//IL_0078: Unknown result type (might be due to invalid IL or missing references)
				//IL_007e: Invalid comparison between Unknown and I4
				if (!__instance.IsServer())
				{
					return;
				}
				BufferingSocket bufferingSocket = new BufferingSocket(rpc.GetSocket());
				AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket);
				object? obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
				ZNetPeer val = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
				if (val != null && (int)ZNet.m_onlineBackend > 0)
				{
					FieldInfo fieldInfo = AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket");
					object? value = fieldInfo.GetValue(val);
					ZPlayFabSocket val2 = (ZPlayFabSocket)((value is ZPlayFabSocket) ? value : null);
					if (val2 != null)
					{
						typeof(ZPlayFabSocket).GetField("m_remotePlayerId").SetValue(bufferingSocket, val2.m_remotePlayerId);
					}
					fieldInfo.SetValue(val, bufferingSocket);
				}
				if (__state == null)
				{
					__state = new Dictionary<Assembly, BufferingSocket>();
				}
				__state[Assembly.GetExecutingAssembly()] = bufferingSocket;
			}

			[HarmonyPostfix]
			private static void Postfix(Dictionary<Assembly, BufferingSocket> __state, ZNet __instance, ZRpc rpc)
			{
				ZNetPeer peer;
				if (__instance.IsServer())
				{
					object obj = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
					peer = (ZNetPeer)((obj is ZNetPeer) ? obj : null);
					if (peer == null)
					{
						SendBufferedData();
					}
					else
					{
						((MonoBehaviour)__instance).StartCoroutine(sendAsync());
					}
				}
				void SendBufferedData()
				{
					if (rpc.GetSocket() is BufferingSocket bufferingSocket)
					{
						AccessTools.DeclaredField(typeof(ZRpc), "m_socket").SetValue(rpc, bufferingSocket.Original);
						object? obj2 = AccessTools.DeclaredMethod(typeof(ZNet), "GetPeer", new Type[1] { typeof(ZRpc) }, (Type[])null).Invoke(__instance, new object[1] { rpc });
						ZNetPeer val = (ZNetPeer)((obj2 is ZNetPeer) ? obj2 : null);
						if (val != null)
						{
							AccessTools.DeclaredField(typeof(ZNetPeer), "m_socket").SetValue(val, bufferingSocket.Original);
						}
					}
					BufferingSocket bufferingSocket2 = __state[Assembly.GetExecutingAssembly()];
					bufferingSocket2.finished = true;
					for (int i = 0; i < bufferingSocket2.Package.Count; i++)
					{
						if (i == bufferingSocket2.versionMatchQueued)
						{
							bufferingSocket2.Original.VersionMatch();
						}
						bufferingSocket2.Original.Send(bufferingSocket2.Package[i]);
					}
					if (bufferingSocket2.Package.Count == bufferingSocket2.versionMatchQueued)
					{
						bufferingSocket2.Original.VersionMatch();
					}
				}
				IEnumerator sendAsync()
				{
					foreach (ConfigSync configSync in configSyncs)
					{
						List<PackageEntry> entries = new List<PackageEntry>();
						if (configSync.CurrentVersion != null)
						{
							entries.Add(new PackageEntry
							{
								section = "Internal",
								key = "serverversion",
								type = typeof(string),
								value = configSync.CurrentVersion
							});
						}
						MethodInfo listContainsId = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList adminList = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						entries.Add(new PackageEntry
						{
							section = "Internal",
							key = "lockexempt",
							type = typeof(bool),
							value = (((object)listContainsId == null) ? ((object)adminList.Contains(rpc.GetSocket().GetHostName())) : listContainsId.Invoke(ZNet.instance, new object[2]
							{
								adminList,
								rpc.GetSocket().GetHostName()
							}))
						});
						ZPackage package = ConfigsToPackage(configSync.allConfigs.Select([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig), configSync.allCustomValues, entries, partial: false);
						yield return ((MonoBehaviour)__instance).StartCoroutine(configSync.sendZPackage(new List<ZNetPeer> { peer }, package));
					}
					SendBufferedData();
				}
			}
		}

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
		private class PackageEntry
		{
			public string section = null;

			public string key = null;

			public Type type = null;

			[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
			public object value;
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "GetSerializedValue")]
		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)]
		private static class PreventSavingServerInfo
		{
			[HarmonyPrefix]
			[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
			private static bool Prefix(ConfigEntryBase __instance, ref string __result)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || isWritableConfig(ownConfigEntryBase))
				{
					return true;
				}
				__result = TomlTypeConverter.ConvertToString(ownConfigEntryBase.LocalBaseValue, __instance.SettingType);
				return false;
			}
		}

		[HarmonyPatch(typeof(ConfigEntryBase), "SetSerializedValue")]
		[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)]
		private static class PreventConfigRereadChangingValues
		{
			[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
			[HarmonyPrefix]
			private static bool Prefix(ConfigEntryBase __instance, string value)
			{
				OwnConfigEntryBase ownConfigEntryBase = configData(__instance);
				if (ownConfigEntryBase == null || ownConfigEntryBase.LocalBaseValue == null)
				{
					return true;
				}
				try
				{
					ownConfigEntryBase.LocalBaseValue = TomlTypeConverter.ConvertToValue(value, __instance.SettingType);
				}
				catch (Exception ex)
				{
					Debug.LogWarning((object)$"Config value of setting \"{__instance.Definition}\" could not be parsed and will be ignored. Reason: {ex.Message}; Value: {value}");
				}
				return false;
			}
		}

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
		private class InvalidDeserializationTypeException : Exception
		{
			public string expected = null;

			public string received = null;

			public string field = "";
		}

		public static bool ProcessingServerUpdate;

		public readonly string Name;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		public string DisplayName;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		public string CurrentVersion;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		public string MinimumRequiredVersion;

		public bool ModRequired = false;

		private bool? forceConfigLocking;

		private bool isSourceOfTruth = true;

		private static readonly HashSet<ConfigSync> configSyncs;

		private readonly HashSet<OwnConfigEntryBase> allConfigs = new HashSet<OwnConfigEntryBase>();

		private HashSet<CustomSyncedValueBase> allCustomValues = new HashSet<CustomSyncedValueBase>();

		private static bool isServer;

		private static bool lockExempt;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private OwnConfigEntryBase lockedConfig = null;

		private const byte PARTIAL_CONFIGS = 1;

		private const byte FRAGMENTED_CONFIG = 2;

		private const byte COMPRESSED_CONFIG = 4;

		private readonly Dictionary<string, SortedDictionary<int, byte[]>> configValueCache = new Dictionary<string, SortedDictionary<int, byte[]>>();

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 1, 0, 1 })]
		private readonly List<KeyValuePair<long, string>> cacheExpirations = new List<KeyValuePair<long, string>>();

		private static long packageCounter;

		public bool IsLocked
		{
			get
			{
				bool? flag = forceConfigLocking;
				bool num;
				if (!flag.HasValue)
				{
					if (lockedConfig == null)
					{
						goto IL_0052;
					}
					num = ((IConvertible)lockedConfig.BaseConfig.BoxedValue).ToInt32(CultureInfo.InvariantCulture) != 0;
				}
				else
				{
					num = flag.GetValueOrDefault();
				}
				if (!num)
				{
					goto IL_0052;
				}
				int result = ((!lockExempt) ? 1 : 0);
				goto IL_0053;
				IL_0053:
				return (byte)result != 0;
				IL_0052:
				result = 0;
				goto IL_0053;
			}
			set
			{
				forceConfigLocking = value;
			}
		}

		public bool IsAdmin => lockExempt || isSourceOfTruth;

		public bool IsSourceOfTruth
		{
			get
			{
				return isSourceOfTruth;
			}
			private set
			{
				if (value != isSourceOfTruth)
				{
					isSourceOfTruth = value;
					this.SourceOfTruthChanged?.Invoke(value);
				}
			}
		}

		public bool InitialSyncDone { get; private set; } = false;


		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		[method: <ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(2)]
		[field: <052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		public event Action<bool> SourceOfTruthChanged;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		[method: <ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(2)]
		[field: <052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private event Action lockedConfigChanged;

		static ConfigSync()
		{
			ProcessingServerUpdate = false;
			configSyncs = new HashSet<ConfigSync>();
			lockExempt = false;
			packageCounter = 0L;
			RuntimeHelpers.RunClassConstructor(typeof(VersionCheck).TypeHandle);
		}

		public ConfigSync(string name)
		{
			Name = name;
			configSyncs.Add(this);
			new VersionCheck(this);
		}

		public SyncedConfigEntry<T> AddConfigEntry<[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)] T>(ConfigEntry<T> configEntry)
		{
			OwnConfigEntryBase ownConfigEntryBase = configData((ConfigEntryBase)(object)configEntry);
			SyncedConfigEntry<T> syncedEntry = ownConfigEntryBase as SyncedConfigEntry<T>;
			if (syncedEntry == null)
			{
				syncedEntry = new SyncedConfigEntry<T>(configEntry);
				AccessTools.DeclaredField(typeof(ConfigDescription), "<Tags>k__BackingField").SetValue(((ConfigEntryBase)configEntry).Description, new object[1]
				{
					new ConfigurationManagerAttributes()
				}.Concat(((ConfigEntryBase)configEntry).Description.Tags ?? Array.Empty<object>()).Concat(new SyncedConfigEntry<T>[1] { syncedEntry }).ToArray());
				configEntry.SettingChanged += [<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (object _, EventArgs _) =>
				{
					if (!ProcessingServerUpdate && syncedEntry.SynchronizedConfig)
					{
						Broadcast(ZRoutedRpc.Everybody, (ConfigEntryBase)configEntry);
					}
				};
				allConfigs.Add(syncedEntry);
			}
			return syncedEntry;
		}

		public SyncedConfigEntry<T> AddLockingConfigEntry<[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)] T>(ConfigEntry<T> lockingConfig) where T : IConvertible
		{
			if (lockedConfig != null)
			{
				throw new Exception("Cannot initialize locking ConfigEntry twice");
			}
			lockedConfig = AddConfigEntry<T>(lockingConfig);
			lockingConfig.SettingChanged += [<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (object _, EventArgs _) =>
			{
				this.lockedConfigChanged?.Invoke();
			};
			return (SyncedConfigEntry<T>)lockedConfig;
		}

		internal void AddCustomValue(CustomSyncedValueBase customValue)
		{
			if (allCustomValues.Select([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (CustomSyncedValueBase v) => v.Identifier).Concat(new string[1] { "serverversion" }).Contains(customValue.Identifier))
			{
				throw new Exception("Cannot have multiple settings with the same name or with a reserved name (serverversion)");
			}
			allCustomValues.Add(customValue);
			allCustomValues = new HashSet<CustomSyncedValueBase>(allCustomValues.OrderByDescending([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (CustomSyncedValueBase v) => v.Priority));
			customValue.ValueChanged += delegate
			{
				if (!ProcessingServerUpdate)
				{
					Broadcast(ZRoutedRpc.Everybody, customValue);
				}
			};
		}

		private void RPC_FromServerConfigSync(ZRpc rpc, ZPackage package)
		{
			lockedConfigChanged += serverLockedSettingChanged;
			IsSourceOfTruth = false;
			if (HandleConfigSyncRPC(0L, package, clientUpdate: false))
			{
				InitialSyncDone = true;
			}
		}

		private void RPC_FromOtherClientConfigSync(long sender, ZPackage package)
		{
			HandleConfigSyncRPC(sender, package, clientUpdate: true);
		}

		private bool HandleConfigSyncRPC(long sender, ZPackage package, bool clientUpdate)
		{
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Expected O, but got Unknown
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Expected O, but got Unknown
			try
			{
				if (isServer && IsLocked)
				{
					ZRpc currentRpc = SnatchCurrentlyHandlingRPC.currentRpc;
					object obj;
					if (currentRpc == null)
					{
						obj = null;
					}
					else
					{
						ISocket socket = currentRpc.GetSocket();
						obj = ((socket != null) ? socket.GetHostName() : null);
					}
					string text = (string)obj;
					if (text != null)
					{
						MethodInfo methodInfo = AccessTools.DeclaredMethod(typeof(ZNet), "ListContainsId", (Type[])null, (Type[])null);
						SyncedList val = (SyncedList)AccessTools.DeclaredField(typeof(ZNet), "m_adminList").GetValue(ZNet.instance);
						if (!(((object)methodInfo == null) ? val.Contains(text) : ((bool)methodInfo.Invoke(ZNet.instance, new object[2] { val, text }))))
						{
							return false;
						}
					}
				}
				cacheExpirations.RemoveAll(([<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 0, 1 })] KeyValuePair<long, string> kv) =>
				{
					if (kv.Key < DateTimeOffset.Now.Ticks)
					{
						configValueCache.Remove(kv.Value);
						return true;
					}
					return false;
				});
				byte b = package.ReadByte();
				if ((b & 2u) != 0)
				{
					long num = package.ReadLong();
					string text2 = sender.ToString() + num;
					if (!configValueCache.TryGetValue(text2, out var value))
					{
						value = new SortedDictionary<int, byte[]>();
						configValueCache[text2] = value;
						cacheExpirations.Add(new KeyValuePair<long, string>(DateTimeOffset.Now.AddSeconds(60.0).Ticks, text2));
					}
					int key = package.ReadInt();
					int num2 = package.ReadInt();
					value.Add(key, package.ReadByteArray());
					if (value.Count < num2)
					{
						return false;
					}
					configValueCache.Remove(text2);
					package = new ZPackage(value.Values.SelectMany([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (byte[] a) => a).ToArray());
					b = package.ReadByte();
				}
				ProcessingServerUpdate = true;
				if ((b & 4u) != 0)
				{
					byte[] buffer = package.ReadByteArray();
					MemoryStream stream = new MemoryStream(buffer);
					MemoryStream memoryStream = new MemoryStream();
					using (DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress))
					{
						deflateStream.CopyTo(memoryStream);
					}
					package = new ZPackage(memoryStream.ToArray());
					b = package.ReadByte();
				}
				if ((b & 1) == 0)
				{
					resetConfigsFromServer();
				}
				ParsedConfigs parsedConfigs = ReadConfigsFromPackage(package);
				ConfigFile val2 = null;
				bool saveOnConfigSet = false;
				foreach (KeyValuePair<OwnConfigEntryBase, object> configValue in parsedConfigs.configValues)
				{
					if (!isServer && configValue.Key.LocalBaseValue == null)
					{
						configValue.Key.LocalBaseValue = configValue.Key.BaseConfig.BoxedValue;
					}
					if (val2 == null)
					{
						val2 = configValue.Key.BaseConfig.ConfigFile;
						saveOnConfigSet = val2.SaveOnConfigSet;
						val2.SaveOnConfigSet = false;
					}
					configValue.Key.BaseConfig.BoxedValue = configValue.Value;
				}
				if (val2 != null)
				{
					val2.SaveOnConfigSet = saveOnConfigSet;
				}
				foreach (KeyValuePair<CustomSyncedValueBase, object> customValue in parsedConfigs.customValues)
				{
					if (!isServer)
					{
						CustomSyncedValueBase key2 = customValue.Key;
						if (key2.LocalBaseValue == null)
						{
							key2.LocalBaseValue = customValue.Key.BoxedValue;
						}
					}
					customValue.Key.BoxedValue = customValue.Value;
				}
				Debug.Log((object)string.Format("Received {0} configs and {1} custom values from {2} for mod {3}", parsedConfigs.configValues.Count, parsedConfigs.customValues.Count, (isServer || clientUpdate) ? $"client {sender}" : "the server", DisplayName ?? Name));
				if (!isServer)
				{
					serverLockedSettingChanged();
				}
				return true;
			}
			finally
			{
				ProcessingServerUpdate = false;
			}
		}

		private ParsedConfigs ReadConfigsFromPackage(ZPackage package)
		{
			ParsedConfigs parsedConfigs = new ParsedConfigs();
			Dictionary<string, OwnConfigEntryBase> dictionary = allConfigs.Where([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (OwnConfigEntryBase c) => c.SynchronizedConfig).ToDictionary([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (OwnConfigEntryBase c) => c.BaseConfig.Definition.Section + "_" + c.BaseConfig.Definition.Key, [<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (OwnConfigEntryBase c) => c);
			Dictionary<string, CustomSyncedValueBase> dictionary2 = allCustomValues.ToDictionary([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (CustomSyncedValueBase c) => c.Identifier, [<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (CustomSyncedValueBase c) => c);
			int num = package.ReadInt();
			for (int i = 0; i < num; i++)
			{
				string text = package.ReadString();
				string text2 = package.ReadString();
				string text3 = package.ReadString();
				Type type = Type.GetType(text3);
				if (text3 == "" || type != null)
				{
					object obj;
					try
					{
						obj = ((text3 == "") ? null : ReadValueWithTypeFromZPackage(package, type));
					}
					catch (InvalidDeserializationTypeException ex)
					{
						Debug.LogWarning((object)("Got unexpected struct internal type " + ex.received + " for field " + ex.field + " struct " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + ex.expected));
						continue;
					}
					OwnConfigEntryBase value2;
					if (text == "Internal")
					{
						CustomSyncedValueBase value;
						if (text2 == "serverversion")
						{
							if (obj?.ToString() != CurrentVersion)
							{
								Debug.LogWarning((object)("Received server version is not equal: server version = " + (obj?.ToString() ?? "null") + "; local version = " + (CurrentVersion ?? "unknown")));
							}
						}
						else if (text2 == "lockexempt")
						{
							if (obj is bool flag)
							{
								lockExempt = flag;
							}
						}
						else if (dictionary2.TryGetValue(text2, out value))
						{
							if ((text3 == "" && (!value.Type.IsValueType || Nullable.GetUnderlyingType(value.Type) != null)) || GetZPackageTypeString(value.Type) == text3)
							{
								parsedConfigs.customValues[value] = obj;
								continue;
							}
							Debug.LogWarning((object)("Got unexpected type " + text3 + " for internal value " + text2 + " for mod " + (DisplayName ?? Name) + ", expecting " + value.Type.AssemblyQualifiedName));
						}
					}
					else if (dictionary.TryGetValue(text + "_" + text2, out value2))
					{
						Type type2 = configType(value2.BaseConfig);
						if ((text3 == "" && (!type2.IsValueType || Nullable.GetUnderlyingType(type2) != null)) || GetZPackageTypeString(type2) == text3)
						{
							parsedConfigs.configValues[value2] = obj;
							continue;
						}
						Debug.LogWarning((object)("Got unexpected type " + text3 + " for " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ", expecting " + type2.AssemblyQualifiedName));
					}
					else
					{
						Debug.LogWarning((object)("Received unknown config entry " + text2 + " in section " + text + " for mod " + (DisplayName ?? Name) + ". This may happen if client and server versions of the mod do not match."));
					}
					continue;
				}
				Debug.LogWarning((object)("Got invalid type " + text3 + ", abort reading of received configs"));
				return new ParsedConfigs();
			}
			return parsedConfigs;
		}

		private static bool isWritableConfig(OwnConfigEntryBase config)
		{
			ConfigSync configSync = configSyncs.FirstOrDefault([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (ConfigSync cs) => cs.allConfigs.Contains(config));
			if (configSync == null)
			{
				return true;
			}
			return configSync.IsSourceOfTruth || !config.SynchronizedConfig || config.LocalBaseValue == null || (!configSync.IsLocked && (config != configSync.lockedConfig || lockExempt));
		}

		private void serverLockedSettingChanged()
		{
			foreach (OwnConfigEntryBase allConfig in allConfigs)
			{
				configAttribute<ConfigurationManagerAttributes>(allConfig.BaseConfig).ReadOnly = !isWritableConfig(allConfig);
			}
		}

		private void resetConfigsFromServer()
		{
			ConfigFile val = null;
			bool saveOnConfigSet = false;
			foreach (OwnConfigEntryBase item in allConfigs.Where([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (OwnConfigEntryBase config) => config.LocalBaseValue != null))
			{
				if (val == null)
				{
					val = item.BaseConfig.ConfigFile;
					saveOnConfigSet = val.SaveOnConfigSet;
					val.SaveOnConfigSet = false;
				}
				item.BaseConfig.BoxedValue = item.LocalBaseValue;
				item.LocalBaseValue = null;
			}
			if (val != null)
			{
				val.SaveOnConfigSet = saveOnConfigSet;
			}
			foreach (CustomSyncedValueBase item2 in allCustomValues.Where([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (CustomSyncedValueBase config) => config.LocalBaseValue != null))
			{
				item2.BoxedValue = item2.LocalBaseValue;
				item2.LocalBaseValue = null;
			}
			lockedConfigChanged -= serverLockedSettingChanged;
			serverLockedSettingChanged();
		}

		private IEnumerator<bool> distributeConfigToPeers(ZNetPeer peer, ZPackage package)
		{
			ZRoutedRpc rpc = ZRoutedRpc.instance;
			if (rpc == null)
			{
				yield break;
			}
			byte[] data = package.GetArray();
			if (data != null && data.LongLength > 250000)
			{
				int fragments = (int)(1 + (data.LongLength - 1) / 250000);
				long packageIdentifier = ++packageCounter;
				int fragment = 0;
				while (fragment < fragments)
				{
					foreach (bool item in waitForQueue())
					{
						yield return item;
					}
					if (peer.m_socket.IsConnected())
					{
						ZPackage fragmentedPackage = new ZPackage();
						fragmentedPackage.Write((byte)2);
						fragmentedPackage.Write(packageIdentifier);
						fragmentedPackage.Write(fragment);
						fragmentedPackage.Write(fragments);
						fragmentedPackage.Write(data.Skip(250000 * fragment).Take(250000).ToArray());
						SendPackage(fragmentedPackage);
						if (fragment != fragments - 1)
						{
							yield return true;
						}
						int num = fragment + 1;
						fragment = num;
						continue;
					}
					break;
				}
				yield break;
			}
			foreach (bool item2 in waitForQueue())
			{
				yield return item2;
			}
			SendPackage(package);
			void SendPackage(ZPackage pkg)
			{
				string text = Name + " ConfigSync";
				if (isServer)
				{
					peer.m_rpc.Invoke(text, new object[1] { pkg });
				}
				else
				{
					rpc.InvokeRoutedRPC(peer.m_server ? 0 : peer.m_uid, text, new object[1] { pkg });
				}
			}
			IEnumerable<bool> waitForQueue()
			{
				float timeout = Time.time + 30f;
				while (peer.m_socket.GetSendQueueSize() > 20000)
				{
					if (Time.time > timeout)
					{
						Debug.Log((object)$"Disconnecting {peer.m_uid} after 30 seconds config sending timeout");
						peer.m_rpc.Invoke("Error", new object[1] { (object)(ConnectionStatus)5 });
						ZNet.instance.Disconnect(peer);
						break;
					}
					yield return false;
				}
			}
		}

		private IEnumerator sendZPackage(long target, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				return Enumerable.Empty<object>().GetEnumerator();
			}
			List<ZNetPeer> list = (List<ZNetPeer>)AccessTools.DeclaredField(typeof(ZRoutedRpc), "m_peers").GetValue(ZRoutedRpc.instance);
			if (target != ZRoutedRpc.Everybody)
			{
				list = list.Where([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (ZNetPeer p) => p.m_uid == target).ToList();
			}
			return sendZPackage(list, package);
		}

		private IEnumerator sendZPackage(List<ZNetPeer> peers, ZPackage package)
		{
			if (!Object.op_Implicit((Object)(object)ZNet.instance))
			{
				yield break;
			}
			byte[] rawData = package.GetArray();
			if (rawData != null && rawData.LongLength > 10000)
			{
				ZPackage compressedPackage = new ZPackage();
				compressedPackage.Write((byte)4);
				MemoryStream output = new MemoryStream();
				using (DeflateStream deflateStream = new DeflateStream(output, CompressionLevel.Optimal))
				{
					deflateStream.Write(rawData, 0, rawData.Length);
				}
				compressedPackage.Write(output.ToArray());
				package = compressedPackage;
			}
			List<IEnumerator<bool>> writers = (from peer in peers
				where peer.IsReady()
				select peer into p
				select distributeConfigToPeers(p, package)).ToList();
			writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			while (writers.Count > 0)
			{
				yield return null;
				writers.RemoveAll((IEnumerator<bool> writer) => !writer.MoveNext());
			}
		}

		private void Broadcast(long target, params ConfigEntryBase[] configs)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(configs);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		private void Broadcast(long target, params CustomSyncedValueBase[] customValues)
		{
			if (!IsLocked || isServer)
			{
				ZPackage package = ConfigsToPackage(null, customValues);
				ZNet instance = ZNet.instance;
				if (instance != null)
				{
					((MonoBehaviour)instance).StartCoroutine(sendZPackage(target, package));
				}
			}
		}

		[return: <052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private static OwnConfigEntryBase configData(ConfigEntryBase config)
		{
			return config.Description.Tags?.OfType<OwnConfigEntryBase>().SingleOrDefault();
		}

		[return: <052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 2, 1 })]
		public static SyncedConfigEntry<T> ConfigData<[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)] T>(ConfigEntry<T> config)
		{
			return ((ConfigEntryBase)config).Description.Tags?.OfType<SyncedConfigEntry<T>>().SingleOrDefault();
		}

		private static T configAttribute<[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)] T>(ConfigEntryBase config)
		{
			return config.Description.Tags.OfType<T>().First();
		}

		private static Type configType(ConfigEntryBase config)
		{
			return configType(config.SettingType);
		}

		private static Type configType(Type type)
		{
			return type.IsEnum ? Enum.GetUnderlyingType(type) : type;
		}

		private static ZPackage ConfigsToPackage([<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 2, 1 })] IEnumerable<ConfigEntryBase> configs = null, [<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 2, 1 })] IEnumerable<CustomSyncedValueBase> customValues = null, [<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 2, 1 })] IEnumerable<PackageEntry> packageEntries = null, bool partial = true)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			List<ConfigEntryBase> list = configs?.Where([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (ConfigEntryBase config) => configData(config).SynchronizedConfig).ToList() ?? new List<ConfigEntryBase>();
			List<CustomSyncedValueBase> list2 = customValues?.ToList() ?? new List<CustomSyncedValueBase>();
			ZPackage val = new ZPackage();
			val.Write((byte)(partial ? 1 : 0));
			val.Write(list.Count + list2.Count + (packageEntries?.Count() ?? 0));
			foreach (PackageEntry item in packageEntries ?? Array.Empty<PackageEntry>())
			{
				AddEntryToPackage(val, item);
			}
			foreach (CustomSyncedValueBase item2 in list2)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = "Internal",
					key = item2.Identifier,
					type = item2.Type,
					value = item2.BoxedValue
				});
			}
			foreach (ConfigEntryBase item3 in list)
			{
				AddEntryToPackage(val, new PackageEntry
				{
					section = item3.Definition.Section,
					key = item3.Definition.Key,
					type = configType(item3),
					value = item3.BoxedValue
				});
			}
			return val;
		}

		private static void AddEntryToPackage(ZPackage package, PackageEntry entry)
		{
			package.Write(entry.section);
			package.Write(entry.key);
			package.Write((entry.value == null) ? "" : GetZPackageTypeString(entry.type));
			AddValueToZPackage(package, entry.value);
		}

		private static string GetZPackageTypeString(Type type)
		{
			return type.AssemblyQualifiedName;
		}

		private static void AddValueToZPackage(ZPackage package, [<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)] object value)
		{
			Type type = value?.GetType();
			if (value is Enum)
			{
				value = ((IConvertible)value).ToType(Enum.GetUnderlyingType(value.GetType()), CultureInfo.InvariantCulture);
			}
			else
			{
				if (value is ICollection collection)
				{
					package.Write(collection.Count);
					{
						foreach (object item in collection)
						{
							AddValueToZPackage(package, item);
						}
						return;
					}
				}
				if ((object)type != null && type.IsValueType && !type.IsPrimitive)
				{
					FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
					package.Write(fields.Length);
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						package.Write(GetZPackageTypeString(fieldInfo.FieldType));
						AddValueToZPackage(package, fieldInfo.GetValue(value));
					}
					return;
				}
			}
			ZRpc.Serialize(new object[1] { value }, ref package);
		}

		private static object ReadValueWithTypeFromZPackage(ZPackage package, Type type)
		{
			if ((object)type != null && type.IsValueType && !type.IsPrimitive && !type.IsEnum)
			{
				FieldInfo[] fields = type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				int num = package.ReadInt();
				if (num != fields.Length)
				{
					throw new InvalidDeserializationTypeException
					{
						received = $"(field count: {num})",
						expected = $"(field count: {fields.Length})"
					};
				}
				object uninitializedObject = FormatterServices.GetUninitializedObject(type);
				FieldInfo[] array = fields;
				foreach (FieldInfo fieldInfo in array)
				{
					string text = package.ReadString();
					if (text != GetZPackageTypeString(fieldInfo.FieldType))
					{
						throw new InvalidDeserializationTypeException
						{
							received = text,
							expected = GetZPackageTypeString(fieldInfo.FieldType),
							field = fieldInfo.Name
						};
					}
					fieldInfo.SetValue(uninitializedObject, ReadValueWithTypeFromZPackage(package, fieldInfo.FieldType));
				}
				return uninitializedObject;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				int num2 = package.ReadInt();
				IDictionary dictionary = (IDictionary)Activator.CreateInstance(type);
				Type type2 = typeof(KeyValuePair<, >).MakeGenericType(type.GenericTypeArguments);
				FieldInfo field = type2.GetField("key", BindingFlags.Instance | BindingFlags.NonPublic);
				FieldInfo field2 = type2.GetField("value", BindingFlags.Instance | BindingFlags.NonPublic);
				for (int j = 0; j < num2; j++)
				{
					object obj = ReadValueWithTypeFromZPackage(package, type2);
					dictionary.Add(field.GetValue(obj), field2.GetValue(obj));
				}
				return dictionary;
			}
			if (type != typeof(List<string>) && type.IsGenericType)
			{
				Type type3 = typeof(ICollection<>).MakeGenericType(type.GenericTypeArguments[0]);
				if ((object)type3 != null && type3.IsAssignableFrom(type))
				{
					int num3 = package.ReadInt();
					object obj2 = Activator.CreateInstance(type);
					MethodInfo method = type3.GetMethod("Add");
					for (int k = 0; k < num3; k++)
					{
						method.Invoke(obj2, new object[1] { ReadValueWithTypeFromZPackage(package, type.GenericTypeArguments[0]) });
					}
					return obj2;
				}
			}
			ParameterInfo parameterInfo = (ParameterInfo)FormatterServices.GetUninitializedObject(typeof(ParameterInfo));
			AccessTools.DeclaredField(typeof(ParameterInfo), "ClassImpl").SetValue(parameterInfo, type);
			List<object> source = new List<object>();
			ZRpc.Deserialize(new ParameterInfo[2] { null, parameterInfo }, package, ref source);
			return source.First();
		}
	}
	[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(0)]
	[<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(1)]
	[HarmonyPatch]
	[PublicAPI]
	internal class VersionCheck
	{
		private static readonly HashSet<VersionCheck> versionChecks;

		private static readonly Dictionary<string, string> notProcessedNames;

		public string Name;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private string displayName;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private string currentVersion;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private string minimumRequiredVersion;

		public bool ModRequired = true;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private string ReceivedCurrentVersion;

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private string ReceivedMinimumRequiredVersion;

		private readonly List<ZRpc> ValidatedClients = new List<ZRpc>();

		[<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)]
		private ConfigSync ConfigSync;

		public string DisplayName
		{
			get
			{
				return displayName ?? Name;
			}
			set
			{
				displayName = value;
			}
		}

		public string CurrentVersion
		{
			get
			{
				return currentVersion ?? "0.0.0";
			}
			set
			{
				currentVersion = value;
			}
		}

		public string MinimumRequiredVersion
		{
			get
			{
				return minimumRequiredVersion ?? (ModRequired ? CurrentVersion : "0.0.0");
			}
			set
			{
				minimumRequiredVersion = value;
			}
		}

		private static void PatchServerSync()
		{
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			Patches patchInfo = PatchProcessor.GetPatchInfo((MethodBase)AccessTools.DeclaredMethod(typeof(ZNet), "Awake", (Type[])null, (Type[])null));
			if (patchInfo != null && patchInfo.Postfixes.Count([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (Patch p) => p.PatchMethod.DeclaringType == typeof(ConfigSync.RegisterRPCPatch)) > 0)
			{
				return;
			}
			Harmony val = new Harmony("org.bepinex.helpers.ServerSync");
			foreach (Type item in from t in typeof(ConfigSync).GetNestedTypes(BindingFlags.NonPublic).Concat(new Type[1] { typeof(VersionCheck) })
				where t.IsClass
				select t)
			{
				val.PatchAll(item);
			}
		}

		static VersionCheck()
		{
			versionChecks = new HashSet<VersionCheck>();
			notProcessedNames = new Dictionary<string, string>();
			typeof(ThreadingHelper).GetMethod("StartSyncInvoke").Invoke(ThreadingHelper.Instance, new object[1]
			{
				new Action(PatchServerSync)
			});
		}

		public VersionCheck(string name)
		{
			Name = name;
			ModRequired = true;
			versionChecks.Add(this);
		}

		public VersionCheck(ConfigSync configSync)
		{
			ConfigSync = configSync;
			Name = ConfigSync.Name;
			versionChecks.Add(this);
		}

		public void Initialize()
		{
			ReceivedCurrentVersion = null;
			ReceivedMinimumRequiredVersion = null;
			if (ConfigSync != null)
			{
				Name = ConfigSync.Name;
				DisplayName = ConfigSync.DisplayName;
				CurrentVersion = ConfigSync.CurrentVersion;
				MinimumRequiredVersion = ConfigSync.MinimumRequiredVersion;
				ModRequired = ConfigSync.ModRequired;
			}
		}

		private bool IsVersionOk()
		{
			if (ReceivedMinimumRequiredVersion == null || ReceivedCurrentVersion == null)
			{
				return !ModRequired;
			}
			bool flag = new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion);
			bool flag2 = new System.Version(ReceivedCurrentVersion) >= new System.Version(MinimumRequiredVersion);
			return flag && flag2;
		}

		private string ErrorClient()
		{
			if (ReceivedMinimumRequiredVersion == null)
			{
				return DisplayName + " is not installed on the server.";
			}
			return (new System.Version(CurrentVersion) >= new System.Version(ReceivedMinimumRequiredVersion)) ? (DisplayName + " may not be higher than version " + ReceivedCurrentVersion + ". You have version " + CurrentVersion + ".") : (DisplayName + " needs to be at least version " + ReceivedMinimumRequiredVersion + ". You have version " + CurrentVersion + ".");
		}

		private string ErrorServer(ZRpc rpc)
		{
			return "Disconnect: The client (" + rpc.GetSocket().GetHostName() + ") doesn't have the correct " + DisplayName + " version " + MinimumRequiredVersion;
		}

		private string Error([<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(2)] ZRpc rpc = null)
		{
			return (rpc == null) ? ErrorClient() : ErrorServer(rpc);
		}

		private static VersionCheck[] GetFailedClient()
		{
			return versionChecks.Where([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (VersionCheck check) => !check.IsVersionOk()).ToArray();
		}

		private static VersionCheck[] GetFailedServer(ZRpc rpc)
		{
			return versionChecks.Where([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (VersionCheck check) => check.ModRequired && !check.ValidatedClients.Contains(rpc)).ToArray();
		}

		private static void Logout()
		{
			Game.instance.Logout(true, true);
			AccessTools.DeclaredField(typeof(ZNet), "m_connectionStatus").SetValue(null, (object)(ConnectionStatus)3);
		}

		private static void DisconnectClient(ZRpc rpc)
		{
			rpc.Invoke("Error", new object[1] { 3 });
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg)
		{
			CheckVersion(rpc, pkg, null);
		}

		private static void CheckVersion(ZRpc rpc, ZPackage pkg, [<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(new byte[] { 2, 1, 1 })] Action<ZRpc, ZPackage> original)
		{
			string text = pkg.ReadString();
			string text2 = pkg.ReadString();
			string text3 = pkg.ReadString();
			bool flag = false;
			foreach (VersionCheck versionCheck in versionChecks)
			{
				if (!(text != versionCheck.Name))
				{
					Debug.Log((object)("Received " + versionCheck.DisplayName + " version " + text3 + " and minimum version " + text2 + " from the " + (ZNet.instance.IsServer() ? "client" : "server") + "."));
					versionCheck.ReceivedMinimumRequiredVersion = text2;
					versionCheck.ReceivedCurrentVersion = text3;
					if (ZNet.instance.IsServer() && versionCheck.IsVersionOk())
					{
						versionCheck.ValidatedClients.Add(rpc);
					}
					flag = true;
				}
			}
			if (flag)
			{
				return;
			}
			pkg.SetPos(0);
			if (original != null)
			{
				original(rpc, pkg);
				if (pkg.GetPos() == 0)
				{
					notProcessedNames.Add(text, text3);
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(ZNet), "RPC_PeerInfo")]
		private static bool RPC_PeerInfo(ZRpc rpc, ZNet __instance)
		{
			VersionCheck[] array = (__instance.IsServer() ? GetFailedServer(rpc) : GetFailedClient());
			if (array.Length == 0)
			{
				return true;
			}
			VersionCheck[] array2 = array;
			foreach (VersionCheck versionCheck in array2)
			{
				Debug.LogWarning((object)versionCheck.Error(rpc));
			}
			if (__instance.IsServer())
			{
				DisconnectClient(rpc);
			}
			else
			{
				Logout();
			}
			return false;
		}

		[HarmonyPatch(typeof(ZNet), "OnNewConnection")]
		[HarmonyPrefix]
		private static void RegisterAndCheckVersion(ZNetPeer peer, ZNet __instance)
		{
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Expected O, but got Unknown
			notProcessedNames.Clear();
			IDictionary dictionary = (IDictionary)typeof(ZRpc).GetField("m_functions", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(peer.m_rpc);
			if (dictionary.Contains(StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")))
			{
				object obj = dictionary[StringExtensionMethods.GetStableHashCode("ServerSync VersionCheck")];
				Action<ZRpc, ZPackage> action = (Action<ZRpc, ZPackage>)obj.GetType().GetField("m_action", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(obj);
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (ZRpc rpc, [<052f11ca-9939-4995-81e6-8224eafe9595>Nullable(1)] ZPackage pkg) =>
				{
					CheckVersion(rpc, pkg, action);
				}));
			}
			else
			{
				peer.m_rpc.Register<ZPackage>("ServerSync VersionCheck", (Action<ZRpc, ZPackage>)CheckVersion);
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.Initialize();
				if (versionCheck.ModRequired || __instance.IsServer())
				{
					Debug.Log((object)("Sending " + versionCheck.DisplayName + " version " + versionCheck.CurrentVersion + " and minimum version " + versionCheck.MinimumRequiredVersion + " to the " + (__instance.IsServer() ? "client" : "server") + "."));
					ZPackage val = new ZPackage();
					val.Write(versionCheck.Name);
					val.Write(versionCheck.MinimumRequiredVersion);
					val.Write(versionCheck.CurrentVersion);
					peer.m_rpc.Invoke("ServerSync VersionCheck", new object[1] { val });
				}
			}
		}

		[HarmonyPatch(typeof(ZNet), "Disconnect")]
		[HarmonyPrefix]
		private static void RemoveDisconnected(ZNetPeer peer, ZNet __instance)
		{
			if (!__instance.IsServer())
			{
				return;
			}
			foreach (VersionCheck versionCheck in versionChecks)
			{
				versionCheck.ValidatedClients.Remove(peer.m_rpc);
			}
		}

		[HarmonyPatch(typeof(FejdStartup), "ShowConnectError")]
		[HarmonyPostfix]
		private static void ShowConnectionError(FejdStartup __instance)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Invalid comparison between Unknown and I4
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.m_connectionFailedPanel.activeSelf || (int)ZNet.GetConnectionStatus() != 3)
			{
				return;
			}
			bool flag = false;
			VersionCheck[] failedClient = GetFailedClient();
			if (failedClient.Length != 0)
			{
				string text = string.Join("\n", failedClient.Select([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (VersionCheck check) => check.Error()));
				TMP_Text connectionFailedError = __instance.m_connectionFailedError;
				connectionFailedError.text = connectionFailedError.text + "\n" + text;
				flag = true;
			}
			foreach (KeyValuePair<string, string> item in notProcessedNames.OrderBy([<ce21fb76-2488-41b6-ae0f-9f438fe17dce>NullableContext(0)] (KeyValuePair<string, string> kv) => kv.Key))
			{
				if (!__instance.m_connectionFailedError.text.Contains(item.Key))
				{
					TMP_Text connectionFailedError2 = __instance.m_connectionFailedError;
					connectionFailedError2.text = connectionFailedError2.text + "\nServer expects you to have " + item.Key + " (Version: " + item.Value + ") installed.";
					flag = true;
				}
			}
			if (flag)
			{
				RectTransform component = ((Component)__instance.m_connectionFailedPanel.transform.Find("Image")).GetComponent<RectTransform>();
				Vector2 sizeDelta = component.sizeDelta;
				sizeDelta.x = 675f;
				component.sizeDelta = sizeDelta;
				__instance.m_connectionFailedError.ForceMeshUpdate(false, false);
				float num = __instance.m_connectionFailedError.renderedHeight + 105f;
				RectTransform component2 = ((Component)((Component)component).transform.Find("ButtonOk")).GetComponent<RectTransform>();
				component2.anchoredPosition = new Vector2(component2.anchoredPosition.x, component2.anchoredPosition.y - (num - component.sizeDelta.y) / 2f);
				sizeDelta = component.sizeDelta;
				sizeDelta.y = num;
				component.sizeDelta = sizeDelta;
			}
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[<93d50f3c-ae98-40cc-af29-62d9fabf83fc>Embedded]
	[CompilerGenerated]
	internal sealed class <93d50f3c-ae98-40cc-af29-62d9fabf83fc>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<93d50f3c-ae98-40cc-af29-62d9fabf83fc>Embedded]
	[CompilerGenerated]
	internal sealed class <dda10819-09af-468b-b453-858f54a2b79b>IsReadOnlyAttribute : Attribute
	{
	}
	[<93d50f3c-ae98-40cc-af29-62d9fabf83fc>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class <f611d04d-bd24-4890-804f-05bc55fa4f32>NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public <f611d04d-bd24-4890-804f-05bc55fa4f32>NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public <f611d04d-bd24-4890-804f-05bc55fa4f32>NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[<93d50f3c-ae98-40cc-af29-62d9fabf83fc>Embedded]
	[CompilerGenerated]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class <0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public <0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace YamlDotNet
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class CultureInfoAdapter : CultureInfo
	{
		private readonly IFormatProvider provider;

		public CultureInfoAdapter(CultureInfo baseCulture, IFormatProvider provider)
			: base(baseCulture.LCID)
		{
			this.provider = provider;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override object GetFormat(Type formatType)
		{
			return provider.GetFormat(formatType);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal static class ReflectionExtensions
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private static readonly FieldInfo RemoteStackTraceField = typeof(Exception).GetField("_remoteStackTraceString", BindingFlags.Instance | BindingFlags.NonPublic);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static Type BaseType(this Type type)
		{
			return type.BaseType;
		}

		public static bool IsValueType(this Type type)
		{
			return type.IsValueType;
		}

		public static bool IsGenericType(this Type type)
		{
			return type.IsGenericType;
		}

		public static bool IsGenericTypeDefinition(this Type type)
		{
			return type.IsGenericTypeDefinition;
		}

		public static bool IsInterface(this Type type)
		{
			return type.IsInterface;
		}

		public static bool IsEnum(this Type type)
		{
			return type.IsEnum;
		}

		public static bool IsDbNull(this object value)
		{
			return value is DBNull;
		}

		public static bool HasDefaultConstructor(this Type type, bool allowPrivateConstructors)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (allowPrivateConstructors)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsValueType)
			{
				return type.GetConstructor(bindingFlags, null, Type.EmptyTypes, null) != null;
			}
			return true;
		}

		public static TypeCode GetTypeCode(this Type type)
		{
			return Type.GetTypeCode(type);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static PropertyInfo GetPublicProperty(this Type type, string name)
		{
			return type.GetProperty(name);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static FieldInfo GetPublicStaticField(this Type type, string name)
		{
			return type.GetField(name, BindingFlags.Static | BindingFlags.Public);
		}

		public static IEnumerable<PropertyInfo> GetProperties(this Type type, bool includeNonPublic)
		{
			BindingFlags bindingFlags = BindingFlags.Instance | BindingFlags.Public;
			if (includeNonPublic)
			{
				bindingFlags |= BindingFlags.NonPublic;
			}
			if (!type.IsInterface)
			{
				return type.GetProperties(bindingFlags);
			}
			return new Type[1] { type }.Concat(type.GetInterfaces()).SelectMany([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (Type i) => i.GetProperties(bindingFlags));
		}

		public static IEnumerable<PropertyInfo> GetPublicProperties(this Type type)
		{
			return type.GetProperties(includeNonPublic: false);
		}

		public static IEnumerable<FieldInfo> GetPublicFields(this Type type)
		{
			return type.GetFields(BindingFlags.Instance | BindingFlags.Public);
		}

		public static IEnumerable<MethodInfo> GetPublicStaticMethods(this Type type)
		{
			return type.GetMethods(BindingFlags.Static | BindingFlags.Public);
		}

		public static MethodInfo GetPrivateStaticMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.NonPublic) ?? throw new MissingMethodException("Expected to find a method named '" + name + "' in '" + type.FullName + "'.");
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static MethodInfo GetPublicStaticMethod(this Type type, string name, params Type[] parameterTypes)
		{
			return type.GetMethod(name, BindingFlags.Static | BindingFlags.Public, null, parameterTypes, null);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static MethodInfo GetPublicInstanceMethod(this Type type, string name)
		{
			return type.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
		}

		public static Exception Unwrap(this TargetInvocationException ex)
		{
			Exception innerException = ex.InnerException;
			if (innerException == null)
			{
				return ex;
			}
			if (RemoteStackTraceField != null)
			{
				RemoteStackTraceField.SetValue(innerException, innerException.StackTrace + "\r\n");
			}
			return innerException;
		}

		public static bool IsInstanceOf(this Type type, object o)
		{
			return type.IsInstanceOfType(o);
		}

		public static Attribute[] GetAllCustomAttributes<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TAttribute>(this PropertyInfo property)
		{
			return Attribute.GetCustomAttributes(property, typeof(TAttribute), inherit: true);
		}
	}
	internal static class PropertyInfoExtensions
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static object ReadValue(this PropertyInfo property, object target)
		{
			return property.GetValue(target, null);
		}
	}
	internal static class StandardRegexOptions
	{
		public const RegexOptions Compiled = RegexOptions.Compiled;
	}
}
namespace YamlDotNet.Serialization
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal abstract class BuilderSkeleton<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TBuilder> where TBuilder : BuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly YamlAttributeOverrides overrides;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool ignoreFields;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal BuilderSkeleton(ITypeResolver typeResolver)
		{
			overrides = new YamlAttributeOverrides();
			typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter>
			{
				{
					typeof(YamlDotNet.Serialization.Converters.GuidConverter),
					(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
				},
				{
					typeof(SystemTypeConverter),
					(Nothing _) => new SystemTypeConverter()
				}
			};
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder IgnoreFields()
		{
			ignoreFields = true;
			return Self;
		}

		public TBuilder IncludeNonPublicProperties()
		{
			includeNonPublicProperties = true;
			return Self;
		}

		public TBuilder EnablePrivateConstructors()
		{
			settings.AllowPrivateConstructors = true;
			return Self;
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(TagName tag, Type type);

		public TBuilder WithAttributeOverride<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			overrides.Add(propertyAccessor, attribute);
			return Self;
		}

		public TBuilder WithAttributeOverride(Type type, string member, Attribute attribute)
		{
			overrides.Add(type, member, attribute);
			return Self;
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	internal delegate TComponent WrapperFactory<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped) where TComponent : TComponentBase;
	internal delegate TComponent WrapperFactory<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TArgument, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TComponentBase, TComponent>(TComponentBase wrapped, TArgument argument) where TComponent : TComponentBase;
	[Flags]
	internal enum DefaultValuesHandling
	{
		Preserve = 0,
		OmitNull = 1,
		OmitDefaults = 2,
		OmitEmptyCollections = 4
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class Deserializer : IDeserializer
	{
		private readonly IValueDeserializer valueDeserializer;

		public Deserializer()
			: this(new DeserializerBuilder().BuildValueDeserializer())
		{
		}

		private Deserializer(IValueDeserializer valueDeserializer)
		{
			this.valueDeserializer = valueDeserializer ?? throw new ArgumentNullException("valueDeserializer");
		}

		public static Deserializer FromValueDeserializer(IValueDeserializer valueDeserializer)
		{
			return new Deserializer(valueDeserializer);
		}

		public T Deserialize<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(string input)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize<T>(input2);
		}

		public T Deserialize<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(TextReader input)
		{
			return Deserialize<T>(new Parser(input));
		}

		public T Deserialize<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(IParser parser)
		{
			return (T)Deserialize(parser, typeof(T));
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object Deserialize(string input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object Deserialize(TextReader input)
		{
			return Deserialize(input, typeof(object));
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object Deserialize(IParser parser)
		{
			return Deserialize(parser, typeof(object));
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object Deserialize(string input, Type type)
		{
			using StringReader input2 = new StringReader(input);
			return Deserialize(input2, type);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object Deserialize(TextReader input, Type type)
		{
			return Deserialize(new Parser(input), type);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object Deserialize(IParser parser, Type type)
		{
			if (parser == null)
			{
				throw new ArgumentNullException("parser");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			YamlDotNet.Core.Events.StreamStart @event;
			bool flag = parser.TryConsume<YamlDotNet.Core.Events.StreamStart>(out @event);
			YamlDotNet.Core.Events.DocumentStart event2;
			bool flag2 = parser.TryConsume<YamlDotNet.Core.Events.DocumentStart>(out event2);
			object result = null;
			if (!parser.Accept<YamlDotNet.Core.Events.DocumentEnd>(out var _) && !parser.Accept<YamlDotNet.Core.Events.StreamEnd>(out var _))
			{
				using SerializerState serializerState = new SerializerState();
				result = valueDeserializer.DeserializeValue(parser, type, serializerState, valueDeserializer);
				serializerState.OnDeserialization();
			}
			if (flag2)
			{
				parser.Consume<YamlDotNet.Core.Events.DocumentEnd>();
			}
			if (flag)
			{
				parser.Consume<YamlDotNet.Core.Events.StreamEnd>();
			}
			return result;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1 })]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class DeserializerBuilder : BuilderSkeleton<DeserializerBuilder>
	{
		private Lazy<IObjectFactory> objectFactory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly Dictionary<Type, Type> typeMappings;

		private readonly ITypeConverter typeConverter;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		protected override DeserializerBuilder Self => this;

		public DeserializerBuilder()
			: base((ITypeResolver)new StaticTypeResolver())
		{
			typeMappings = new Dictionary<Type, Type>();
			objectFactory = new Lazy<IObjectFactory>(() => new DefaultObjectFactory(typeMappings, settings), isThreadSafe: true);
			tagMappings = new Dictionary<TagName, Type>
			{
				{
					FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
			typeInspectorFactories.Add(typeof(ReadableAndWritablePropertiesTypeInspector), (ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner));
			nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
			{
				{
					typeof(YamlConvertibleNodeDeserializer),
					(Nothing _) => new YamlConvertibleNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(YamlSerializableNodeDeserializer),
					(Nothing _) => new YamlSerializableNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(TypeConverterNodeDeserializer),
					(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(NullNodeDeserializer),
					(Nothing _) => new NullNodeDeserializer()
				},
				{
					typeof(ScalarNodeDeserializer),
					(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, yamlFormatter)
				},
				{
					typeof(ArrayNodeDeserializer),
					(Nothing _) => new ArrayNodeDeserializer()
				},
				{
					typeof(DictionaryNodeDeserializer),
					(Nothing _) => new DictionaryNodeDeserializer(objectFactory.Value, duplicateKeyChecking)
				},
				{
					typeof(CollectionNodeDeserializer),
					(Nothing _) => new CollectionNodeDeserializer(objectFactory.Value)
				},
				{
					typeof(EnumerableNodeDeserializer),
					(Nothing _) => new EnumerableNodeDeserializer()
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(objectFactory.Value, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
				}
			};
			nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
			{
				{
					typeof(MappingNodeTypeResolver),
					(Nothing _) => new MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(YamlConvertibleTypeResolver),
					(Nothing _) => new YamlConvertibleTypeResolver()
				},
				{
					typeof(YamlSerializableTypeResolver),
					(Nothing _) => new YamlSerializableTypeResolver()
				},
				{
					typeof(TagNodeTypeResolver),
					(Nothing _) => new TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(PreventUnknownTagsNodeTypeResolver),
					(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(DefaultContainersNodeTypeResolver),
					(Nothing _) => new DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new ReflectionTypeConverter();
		}

		internal ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new WritablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public DeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public DeserializerBuilder WithObjectFactory(IObjectFactory objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			this.objectFactory = new Lazy<IObjectFactory>(() => objectFactory, isThreadSafe: true);
			return this;
		}

		public DeserializerBuilder WithObjectFactory(Func<Type, object> objectFactory)
		{
			if (objectFactory == null)
			{
				throw new ArgumentNullException("objectFactory");
			}
			return WithObjectFactory(new LambdaObjectFactory(objectFactory));
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
			return this;
		}

		public DeserializerBuilder WithNodeDeserializer<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeDeserializer<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public DeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public DeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
			{
				s.Before<DictionaryNodeDeserializer>();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public DeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
			return this;
		}

		public DeserializerBuilder WithNodeTypeResolver<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public DeserializerBuilder WithoutNodeTypeResolver<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public DeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override DeserializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out var value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public DeserializerBuilder WithTypeMapping<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TInterface, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (typeMappings.ContainsKey(typeFromHandle))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			else
			{
				typeMappings.Add(typeFromHandle, typeFromHandle2);
			}
			return this;
		}

		public DeserializerBuilder WithoutTagMapping(TagName tag)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (!tagMappings.Remove(tag))
			{
				throw new KeyNotFoundException($"Tag '{tag}' is not registered");
			}
			return this;
		}

		public DeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public DeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public IDeserializer Build()
		{
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class EmissionPhaseObjectGraphVisitorArgs
	{
		private readonly IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors;

		public IObjectGraphVisitor<IEmitter> InnerVisitor { get; private set; }

		public IEventEmitter EventEmitter { get; private set; }

		public ObjectSerializer NestedObjectSerializer { get; private set; }

		public IEnumerable<IYamlTypeConverter> TypeConverters { get; private set; }

		public EmissionPhaseObjectGraphVisitorArgs(IObjectGraphVisitor<IEmitter> innerVisitor, IEventEmitter eventEmitter, IEnumerable<IObjectGraphVisitor<Nothing>> preProcessingPhaseVisitors, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
		{
			InnerVisitor = innerVisitor ?? throw new ArgumentNullException("innerVisitor");
			EventEmitter = eventEmitter ?? throw new ArgumentNullException("eventEmitter");
			this.preProcessingPhaseVisitors = preProcessingPhaseVisitors ?? throw new ArgumentNullException("preProcessingPhaseVisitors");
			TypeConverters = typeConverters ?? throw new ArgumentNullException("typeConverters");
			NestedObjectSerializer = nestedObjectSerializer ?? throw new ArgumentNullException("nestedObjectSerializer");
		}

		public T GetPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>() where T : IObjectGraphVisitor<Nothing>
		{
			return preProcessingPhaseVisitors.OfType<T>().Single();
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal abstract class EventInfo
	{
		public IObjectDescriptor Source { get; }

		protected EventInfo(IObjectDescriptor source)
		{
			Source = source ?? throw new ArgumentNullException("source");
		}
	}
	internal class AliasEventInfo : EventInfo
	{
		public AnchorName Alias { get; }

		public bool NeedsExpansion { get; set; }

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public AliasEventInfo(IObjectDescriptor source, AnchorName alias)
			: base(source)
		{
			if (alias.IsEmpty)
			{
				throw new ArgumentNullException("alias");
			}
			Alias = alias;
		}
	}
	internal class ObjectEventInfo : EventInfo
	{
		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		protected ObjectEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class ScalarEventInfo : ObjectEventInfo
	{
		public string RenderedValue { get; set; }

		public ScalarStyle Style { get; set; }

		public bool IsPlainImplicit { get; set; }

		public bool IsQuotedImplicit { get; set; }

		public ScalarEventInfo(IObjectDescriptor source)
			: base(source)
		{
			Style = source.ScalarStyle;
			RenderedValue = string.Empty;
		}
	}
	internal sealed class MappingStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public MappingStyle Style { get; set; }

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public MappingStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class MappingEndEventInfo : EventInfo
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public MappingEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceStartEventInfo : ObjectEventInfo
	{
		public bool IsImplicit { get; set; }

		public SequenceStyle Style { get; set; }

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public SequenceStartEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	internal sealed class SequenceEndEventInfo : EventInfo
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public SequenceEndEventInfo(IObjectDescriptor source)
			: base(source)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IAliasProvider
	{
		AnchorName GetAlias(object target);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IDeserializer
	{
		T Deserialize<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(string input);

		T Deserialize<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(TextReader input);

		T Deserialize<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(IParser parser);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Deserialize(string input);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Deserialize(TextReader input);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Deserialize(IParser parser);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Deserialize(string input, Type type);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Deserialize(TextReader input, Type type);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Deserialize(IParser parser, Type type);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IEventEmitter
	{
		void Emit(AliasEventInfo eventInfo, IEmitter emitter);

		void Emit(ScalarEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingStartEventInfo eventInfo, IEmitter emitter);

		void Emit(MappingEndEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter);

		void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface INamingConvention
	{
		string Apply(string value);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface INodeDeserializer
	{
		bool Deserialize(IParser reader, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface INodeTypeResolver
	{
		bool Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IObjectAccessor
	{
		void Set(string name, object target, object value);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Read(string name, object target);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IObjectDescriptor
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object Value
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get;
		}

		Type Type { get; }

		Type StaticType { get; }

		ScalarStyle ScalarStyle { get; }
	}
	internal static class ObjectDescriptorExtensions
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public static object NonNullValue(this IObjectDescriptor objectDescriptor)
		{
			return objectDescriptor.Value ?? throw new InvalidOperationException("Attempted to use a IObjectDescriptor of type '" + objectDescriptor.Type.FullName + "' whose Value is null at a point whete it is invalid to do so. This may indicate a bug in YamlDotNet.");
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IObjectFactory
	{
		object Create(Type type);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object CreatePrimitive(Type type);

		bool GetDictionary(IObjectDescriptor descriptor, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out IDictionary dictionary, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments);

		Type GetValueType(Type type);

		void ExecuteOnDeserializing(object value);

		void ExecuteOnDeserialized(object value);

		void ExecuteOnSerializing(object value);

		void ExecuteOnSerialized(object value);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IObjectGraphTraversalStrategy
	{
		void Traverse<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>
	{
		bool Enter(IObjectDescriptor value, TContext context);

		bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, TContext context);

		bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, TContext context);

		void VisitScalar(IObjectDescriptor scalar, TContext context);

		void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, TContext context);

		void VisitMappingEnd(IObjectDescriptor mapping, TContext context);

		void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, TContext context);

		void VisitSequenceEnd(IObjectDescriptor sequence, TContext context);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IPropertyDescriptor
	{
		string Name { get; }

		bool CanWrite { get; }

		Type Type { get; }

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		Type TypeOverride
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get;
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			set;
		}

		int Order { get; set; }

		ScalarStyle ScalarStyle { get; set; }

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		T GetCustomAttribute<T>() where T : Attribute;

		IObjectDescriptor Read(object target);

		void Write(object target, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value);
	}
	internal interface IRegistrationLocationSelectionSyntax<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void Before<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void After<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;

		void OnTop();

		void OnBottom();
	}
	internal interface ITrackingRegistrationLocationSelectionSyntax<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TBaseRegistrationType>
	{
		void InsteadOf<TRegistrationType>() where TRegistrationType : TBaseRegistrationType;
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface ISerializer
	{
		string Serialize([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph);

		string Serialize([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph, Type type);

		void Serialize(TextWriter writer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph);

		void Serialize(TextWriter writer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph, Type type);

		void Serialize(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph);

		void Serialize(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph, Type type);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface ITypeInspector
	{
		IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container);

		IPropertyDescriptor GetProperty(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface ITypeResolver
	{
		Type Resolve(Type staticType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object actualValue);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IValueDeserializer
	{
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer);
	}
	internal interface IValuePromise
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 2 })]
		event Action<object> ValueAvailable;
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	internal interface IValueSerializer
	{
		void SerializeValue([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEmitter emitter, object value, Type type);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IYamlConvertible
	{
		void Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer);

		void Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer);
	}
	[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
	internal delegate object ObjectDeserializer(Type type);
	internal delegate void ObjectSerializer(object value, Type type = null);
	[Obsolete("Please use IYamlConvertible instead")]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IYamlSerializable
	{
		void ReadYaml(IParser parser);

		void WriteYaml(IEmitter emitter);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IYamlTypeConverter
	{
		bool Accepts(Type type);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		object ReadYaml(IParser parser, Type type);

		void WriteYaml(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type type);
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class LazyComponentRegistrationList<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TArgument, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TComponent> : IEnumerable<Func<TArgument, TComponent>>, IEnumerable
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		public sealed class LazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TArgument, TComponent> Factory;

			public LazyComponentRegistration(Type componentType, Func<TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		public sealed class TrackingLazyComponentRegistration
		{
			public readonly Type ComponentType;

			public readonly Func<TComponent, TArgument, TComponent> Factory;

			public TrackingLazyComponentRegistration(Type componentType, Func<TComponent, TArgument, TComponent> factory)
			{
				ComponentType = componentType;
				Factory = factory;
			}
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		private class RegistrationLocationSelector : IRegistrationLocationSelectionSyntax<TComponent>
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 0 })]
			private readonly LazyComponentRegistration newRegistration;

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			public RegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 0 })] LazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries[index] = newRegistration;
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.After<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int num = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(num + 1, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.Before<TRegistrationType>()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				registrations.entries.Insert(index, newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnBottom()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Add(newRegistration);
			}

			void IRegistrationLocationSelectionSyntax<TComponent>.OnTop()
			{
				registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				registrations.entries.Insert(0, newRegistration);
			}
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		private class TrackingRegistrationLocationSelector : ITrackingRegistrationLocationSelectionSyntax<TComponent>
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
			private readonly LazyComponentRegistrationList<TArgument, TComponent> registrations;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 0 })]
			private readonly TrackingLazyComponentRegistration newRegistration;

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			public TrackingRegistrationLocationSelector(LazyComponentRegistrationList<TArgument, TComponent> registrations, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 0 })] TrackingLazyComponentRegistration newRegistration)
			{
				this.registrations = registrations;
				this.newRegistration = newRegistration;
			}

			void ITrackingRegistrationLocationSelectionSyntax<TComponent>.InsteadOf<TRegistrationType>()
			{
				if (newRegistration.ComponentType != typeof(TRegistrationType))
				{
					registrations.EnsureNoDuplicateRegistrationType(newRegistration.ComponentType);
				}
				int index = registrations.EnsureRegistrationExists<TRegistrationType>();
				Func<TArgument, TComponent> innerComponentFactory = registrations.entries[index].Factory;
				registrations.entries[index] = new LazyComponentRegistration(newRegistration.ComponentType, [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)] (TArgument arg) => newRegistration.Factory(innerComponentFactory(arg), arg));
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 0, 0 })]
		private readonly List<LazyComponentRegistration> entries = new List<LazyComponentRegistration>();

		public int Count => entries.Count;

		public IEnumerable<Func<TArgument, TComponent>> InReverseOrder
		{
			get
			{
				int i = entries.Count - 1;
				while (i >= 0)
				{
					yield return entries[i].Factory;
					int num = i - 1;
					i = num;
				}
			}
		}

		public LazyComponentRegistrationList<TArgument, TComponent> Clone()
		{
			LazyComponentRegistrationList<TArgument, TComponent> lazyComponentRegistrationList = new LazyComponentRegistrationList<TArgument, TComponent>();
			foreach (LazyComponentRegistration entry in entries)
			{
				lazyComponentRegistrationList.entries.Add(entry);
			}
			return lazyComponentRegistrationList;
		}

		public void Clear()
		{
			entries.Clear();
		}

		public void Add(Type componentType, Func<TArgument, TComponent> factory)
		{
			entries.Add(new LazyComponentRegistration(componentType, factory));
		}

		public void Remove(Type componentType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (entries[i].ComponentType == componentType)
				{
					entries.RemoveAt(i);
					return;
				}
			}
			throw new KeyNotFoundException("A component registration of type '" + componentType.FullName + "' was not found.");
		}

		public IRegistrationLocationSelectionSyntax<TComponent> CreateRegistrationLocationSelector(Type componentType, Func<TArgument, TComponent> factory)
		{
			return new RegistrationLocationSelector(this, new LazyComponentRegistration(componentType, factory));
		}

		public ITrackingRegistrationLocationSelectionSyntax<TComponent> CreateTrackingRegistrationLocationSelector(Type componentType, Func<TComponent, TArgument, TComponent> factory)
		{
			return new TrackingRegistrationLocationSelector(this, new TrackingLazyComponentRegistration(componentType, factory));
		}

		public IEnumerator<Func<TArgument, TComponent>> GetEnumerator()
		{
			return entries.Select([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (LazyComponentRegistration e) => e.Factory).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private int IndexOfRegistration(Type registrationType)
		{
			for (int i = 0; i < entries.Count; i++)
			{
				if (registrationType == entries[i].ComponentType)
				{
					return i;
				}
			}
			return -1;
		}

		private void EnsureNoDuplicateRegistrationType(Type componentType)
		{
			if (IndexOfRegistration(componentType) != -1)
			{
				throw new InvalidOperationException("A component of type '" + componentType.FullName + "' has already been registered.");
			}
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private int EnsureRegistrationExists<TRegistrationType>()
		{
			int num = IndexOfRegistration(typeof(TRegistrationType));
			if (num == -1)
			{
				throw new InvalidOperationException("A component of type '" + typeof(TRegistrationType).FullName + "' has not been registered.");
			}
			return num;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal static class LazyComponentRegistrationListExtensions
	{
		public static TComponent BuildComponentChain<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TComponent, TComponent> registrations, TComponent innerComponent)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (TComponent inner, Func<TComponent, TComponent> factory) => factory(inner));
		}

		public static TComponent BuildComponentChain<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TArgument, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TComponent innerComponent, Func<TComponent, TArgument> argumentBuilder)
		{
			return registrations.InReverseOrder.Aggregate(innerComponent, [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (TComponent inner, Func<TArgument, TComponent> factory) => factory(argumentBuilder(inner)));
		}

		public static List<TComponent> BuildComponentList<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TComponent>(this LazyComponentRegistrationList<Nothing, TComponent> registrations)
		{
			return registrations.Select([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (Func<Nothing, TComponent> factory) => factory(default(Nothing))).ToList();
		}

		public static List<TComponent> BuildComponentList<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TArgument, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TComponent>(this LazyComponentRegistrationList<TArgument, TComponent> registrations, TArgument argument)
		{
			return registrations.Select([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (Func<TArgument, TComponent> factory) => factory(argument)).ToList();
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct Nothing
	{
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class ObjectDescriptor : IObjectDescriptor
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		[field: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object Value
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get;
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			private set;
		}

		public Type Type { get; private set; }

		public Type StaticType { get; private set; }

		public ScalarStyle ScalarStyle { get; private set; }

		public ObjectDescriptor([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type type, Type staticType)
			: this(value, type, staticType, ScalarStyle.Any)
		{
		}

		public ObjectDescriptor([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type type, Type staticType, ScalarStyle scalarStyle)
		{
			Value = value;
			Type = type ?? throw new ArgumentNullException("type");
			StaticType = staticType ?? throw new ArgumentNullException("staticType");
			ScalarStyle = scalarStyle;
		}
	}
	internal delegate IObjectGraphTraversalStrategy ObjectGraphTraversalStrategyFactory(ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion);
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class PropertyDescriptor : IPropertyDescriptor
	{
		private readonly IPropertyDescriptor baseDescriptor;

		public string Name { get; set; }

		public Type Type => baseDescriptor.Type;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public Type TypeOverride
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get
			{
				return baseDescriptor.TypeOverride;
			}
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			set
			{
				baseDescriptor.TypeOverride = value;
			}
		}

		public int Order { get; set; }

		public ScalarStyle ScalarStyle
		{
			get
			{
				return baseDescriptor.ScalarStyle;
			}
			set
			{
				baseDescriptor.ScalarStyle = value;
			}
		}

		public bool CanWrite => baseDescriptor.CanWrite;

		public PropertyDescriptor(IPropertyDescriptor baseDescriptor)
		{
			this.baseDescriptor = baseDescriptor;
			Name = baseDescriptor.Name;
		}

		public void Write(object target, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value)
		{
			baseDescriptor.Write(target, value);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public T GetCustomAttribute<T>() where T : Attribute
		{
			return baseDescriptor.GetCustomAttribute<T>();
		}

		public IObjectDescriptor Read(object target)
		{
			return baseDescriptor.Read(target);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class Serializer : ISerializer
	{
		private readonly IValueSerializer valueSerializer;

		private readonly EmitterSettings emitterSettings;

		public Serializer()
			: this(new SerializerBuilder().BuildValueSerializer(), EmitterSettings.Default)
		{
		}

		private Serializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
		{
			this.valueSerializer = valueSerializer ?? throw new ArgumentNullException("valueSerializer");
			this.emitterSettings = emitterSettings ?? throw new ArgumentNullException("emitterSettings");
		}

		public static Serializer FromValueSerializer(IValueSerializer valueSerializer, EmitterSettings emitterSettings)
		{
			return new Serializer(valueSerializer, emitterSettings);
		}

		public string Serialize([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph);
			return stringWriter.ToString();
		}

		public string Serialize([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph, Type type)
		{
			using StringWriter stringWriter = new StringWriter();
			Serialize(stringWriter, graph, type);
			return stringWriter.ToString();
		}

		public void Serialize(TextWriter writer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph)
		{
			Serialize(new Emitter(writer, emitterSettings), graph);
		}

		public void Serialize(TextWriter writer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph, Type type)
		{
			Serialize(new Emitter(writer, emitterSettings), graph, type);
		}

		public void Serialize(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			EmitDocument(emitter, graph, null);
		}

		public void Serialize(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object graph, Type type)
		{
			if (emitter == null)
			{
				throw new ArgumentNullException("emitter");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			EmitDocument(emitter, graph, type);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private void EmitDocument([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEmitter emitter, object graph, Type type)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			valueSerializer.SerializeValue(emitter, graph, type);
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: true));
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1 })]
	internal sealed class SerializerBuilder : BuilderSkeleton<SerializerBuilder>
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

			private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			public void SerializeValue([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEmitter emitter, object value, Type type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing));
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new EmittingObjectGraphVisitor(eventEmitter), [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				void NestedObjectSerializer(object v, Type t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly IDictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

		private readonly IObjectFactory objectFactory;

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private ScalarStyle defaultScalarStyle;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		protected override SerializerBuilder Self => this;

		public SerializerBuilder()
			: base((ITypeResolver)new DynamicTypeResolver())
		{
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			typeInspectorFactories.Add(typeof(YamlAttributeOverridesInspector), (ITypeInspector inner) => (overrides == null) ? inner : new YamlAttributeOverridesInspector(inner, overrides.Clone()));
			preProcessingPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> { 
			{
				typeof(AnchorAssigner),
				(IEnumerable<IYamlTypeConverter> typeConverters) => new AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>
			{
				{
					typeof(CustomSerializationObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(AnchorAssigningObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<AnchorAssigner>())
				},
				{
					typeof(DefaultValuesObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, new DefaultObjectFactory())
				},
				{
					typeof(CommentsObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> { 
			{
				typeof(TypeAssigningEventEmitter),
				(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter)
			} };
			objectFactory = new DefaultObjectFactory();
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, objectFactory);
		}

		public SerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public SerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

		public SerializerBuilder WithMaximumRecursion(int maximumRecursion)
		{
			if (maximumRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
			}
			this.maximumRecursion = maximumRecursion;
			return this;
		}

		public SerializerBuilder WithEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner)));
			return Self;
		}

		public SerializerBuilder WithEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public SerializerBuilder WithoutEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public SerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override SerializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public SerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public SerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, objectFactory);
			WithEventEmitter([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] ([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] ([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public SerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public SerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
		}

		public SerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public SerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new YamlDotNet.Serialization.Converters.DateTimeConverter(DateTimeKind.Utc, null, true)).WithEventEmitter([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] ([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public SerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public SerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public SerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public SerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public SerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public ISerializer Build()
		{
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public IValueSerializer BuildValueSerializer()
		{
			IEnumerable<IYamlTypeConverter> typeConverters = BuildTypeConverters();
			ITypeInspector typeInspector = BuildTypeInspector();
			IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		internal ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = new ReadablePropertiesTypeInspector(typeResolver, includeNonPublicProperties);
			if (!ignoreFields)
			{
				typeInspector = new CompositeTypeInspector(new ReadableFieldsTypeInspector(typeResolver), typeInspector);
			}
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	internal class Settings
	{
		public bool AllowPrivateConstructors { get; set; }
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal abstract class StaticBuilderSkeleton<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TBuilder> where TBuilder : StaticBuilderSkeleton<TBuilder>
	{
		internal INamingConvention namingConvention = NullNamingConvention.Instance;

		internal ITypeResolver typeResolver;

		internal readonly LazyComponentRegistrationList<Nothing, IYamlTypeConverter> typeConverterFactories;

		internal readonly LazyComponentRegistrationList<ITypeInspector, ITypeInspector> typeInspectorFactories;

		internal bool includeNonPublicProperties;

		internal Settings settings;

		internal YamlFormatter yamlFormatter = YamlFormatter.Default;

		protected abstract TBuilder Self { get; }

		internal StaticBuilderSkeleton(ITypeResolver typeResolver)
		{
			typeConverterFactories = new LazyComponentRegistrationList<Nothing, IYamlTypeConverter> { 
			{
				typeof(YamlDotNet.Serialization.Converters.GuidConverter),
				(Nothing _) => new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: false)
			} };
			typeInspectorFactories = new LazyComponentRegistrationList<ITypeInspector, ITypeInspector>();
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			settings = new Settings();
		}

		public TBuilder WithNamingConvention(INamingConvention namingConvention)
		{
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			return Self;
		}

		public TBuilder WithTypeResolver(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			return Self;
		}

		public abstract TBuilder WithTagMapping(TagName tag, Type type);

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter)
		{
			return WithTypeConverter(typeConverter, delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeConverter(IYamlTypeConverter typeConverter, Action<IRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where)
		{
			if (typeConverter == null)
			{
				throw new ArgumentNullException("typeConverter");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateRegistrationLocationSelector(typeConverter.GetType(), (Nothing _) => typeConverter));
			return Self;
		}

		public TBuilder WithTypeConverter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TYamlTypeConverter>(WrapperFactory<IYamlTypeConverter, IYamlTypeConverter> typeConverterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IYamlTypeConverter>> where) where TYamlTypeConverter : IYamlTypeConverter
		{
			if (typeConverterFactory == null)
			{
				throw new ArgumentNullException("typeConverterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeConverterFactories.CreateTrackingRegistrationLocationSelector(typeof(TYamlTypeConverter), (IYamlTypeConverter wrapped, Nothing _) => typeConverterFactory(wrapped)));
			return Self;
		}

		public TBuilder WithoutTypeConverter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TYamlTypeConverter>() where TYamlTypeConverter : IYamlTypeConverter
		{
			return WithoutTypeConverter(typeof(TYamlTypeConverter));
		}

		public TBuilder WithoutTypeConverter(Type converterType)
		{
			if (converterType == null)
			{
				throw new ArgumentNullException("converterType");
			}
			typeConverterFactories.Remove(converterType);
			return Self;
		}

		public TBuilder WithTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory) where TTypeInspector : ITypeInspector
		{
			return WithTypeInspector(typeInspectorFactory, delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> w)
			{
				w.OnTop();
			});
		}

		public TBuilder WithTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>(Func<ITypeInspector, TTypeInspector> typeInspectorFactory, Action<IRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector inner) => typeInspectorFactory(inner)));
			return Self;
		}

		public TBuilder WithTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>(WrapperFactory<ITypeInspector, ITypeInspector, TTypeInspector> typeInspectorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<ITypeInspector>> where) where TTypeInspector : ITypeInspector
		{
			if (typeInspectorFactory == null)
			{
				throw new ArgumentNullException("typeInspectorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(typeInspectorFactories.CreateTrackingRegistrationLocationSelector(typeof(TTypeInspector), (ITypeInspector wrapped, ITypeInspector inner) => typeInspectorFactory(wrapped, inner)));
			return Self;
		}

		public TBuilder WithoutTypeInspector<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TTypeInspector>() where TTypeInspector : ITypeInspector
		{
			return WithoutTypeInspector(typeof(TTypeInspector));
		}

		public TBuilder WithoutTypeInspector(Type inspectorType)
		{
			if (inspectorType == null)
			{
				throw new ArgumentNullException("inspectorType");
			}
			typeInspectorFactories.Remove(inspectorType);
			return Self;
		}

		public TBuilder WithYamlFormatter(YamlFormatter formatter)
		{
			yamlFormatter = formatter ?? throw new ArgumentNullException("formatter");
			return Self;
		}

		protected IEnumerable<IYamlTypeConverter> BuildTypeConverters()
		{
			return typeConverterFactories.BuildComponentList();
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal abstract class StaticContext
	{
		public virtual bool IsKnownType(Type type)
		{
			throw new NotImplementedException();
		}

		public virtual ITypeResolver GetTypeResolver()
		{
			throw new NotImplementedException();
		}

		public virtual StaticObjectFactory GetFactory()
		{
			throw new NotImplementedException();
		}

		public virtual ITypeInspector GetTypeInspector()
		{
			throw new NotImplementedException();
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1 })]
	internal sealed class StaticDeserializerBuilder : StaticBuilderSkeleton<StaticDeserializerBuilder>
	{
		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private readonly LazyComponentRegistrationList<Nothing, INodeDeserializer> nodeDeserializerFactories;

		private readonly LazyComponentRegistrationList<Nothing, INodeTypeResolver> nodeTypeResolverFactories;

		private readonly Dictionary<TagName, Type> tagMappings;

		private readonly ITypeConverter typeConverter;

		private readonly Dictionary<Type, Type> typeMappings;

		private bool ignoreUnmatched;

		private bool duplicateKeyChecking;

		private bool attemptUnknownTypeDeserialization;

		protected override StaticDeserializerBuilder Self => this;

		public StaticDeserializerBuilder(StaticContext context)
			: base(context.GetTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeMappings = new Dictionary<Type, Type>();
			tagMappings = new Dictionary<TagName, Type>
			{
				{
					FailsafeSchema.Tags.Map,
					typeof(Dictionary<object, object>)
				},
				{
					FailsafeSchema.Tags.Str,
					typeof(string)
				},
				{
					JsonSchema.Tags.Bool,
					typeof(bool)
				},
				{
					JsonSchema.Tags.Float,
					typeof(double)
				},
				{
					JsonSchema.Tags.Int,
					typeof(int)
				},
				{
					DefaultSchema.Tags.Timestamp,
					typeof(DateTime)
				}
			};
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			nodeDeserializerFactories = new LazyComponentRegistrationList<Nothing, INodeDeserializer>
			{
				{
					typeof(YamlConvertibleNodeDeserializer),
					(Nothing _) => new YamlConvertibleNodeDeserializer(factory)
				},
				{
					typeof(YamlSerializableNodeDeserializer),
					(Nothing _) => new YamlSerializableNodeDeserializer(factory)
				},
				{
					typeof(TypeConverterNodeDeserializer),
					(Nothing _) => new TypeConverterNodeDeserializer(BuildTypeConverters())
				},
				{
					typeof(NullNodeDeserializer),
					(Nothing _) => new NullNodeDeserializer()
				},
				{
					typeof(ScalarNodeDeserializer),
					(Nothing _) => new ScalarNodeDeserializer(attemptUnknownTypeDeserialization, typeConverter, yamlFormatter)
				},
				{
					typeof(StaticArrayNodeDeserializer),
					(Nothing _) => new StaticArrayNodeDeserializer(factory)
				},
				{
					typeof(StaticDictionaryNodeDeserializer),
					(Nothing _) => new StaticDictionaryNodeDeserializer(factory, duplicateKeyChecking)
				},
				{
					typeof(StaticCollectionNodeDeserializer),
					(Nothing _) => new StaticCollectionNodeDeserializer(factory)
				},
				{
					typeof(ObjectNodeDeserializer),
					(Nothing _) => new ObjectNodeDeserializer(factory, BuildTypeInspector(), ignoreUnmatched, duplicateKeyChecking, typeConverter)
				}
			};
			nodeTypeResolverFactories = new LazyComponentRegistrationList<Nothing, INodeTypeResolver>
			{
				{
					typeof(MappingNodeTypeResolver),
					(Nothing _) => new MappingNodeTypeResolver(typeMappings)
				},
				{
					typeof(YamlConvertibleTypeResolver),
					(Nothing _) => new YamlConvertibleTypeResolver()
				},
				{
					typeof(YamlSerializableTypeResolver),
					(Nothing _) => new YamlSerializableTypeResolver()
				},
				{
					typeof(TagNodeTypeResolver),
					(Nothing _) => new TagNodeTypeResolver(tagMappings)
				},
				{
					typeof(PreventUnknownTagsNodeTypeResolver),
					(Nothing _) => new PreventUnknownTagsNodeTypeResolver()
				},
				{
					typeof(DefaultContainersNodeTypeResolver),
					(Nothing _) => new DefaultContainersNodeTypeResolver()
				}
			};
			typeConverter = new NullTypeConverter();
		}

		internal ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}

		public StaticDeserializerBuilder WithAttemptingUnquotedStringTypeDeserialization()
		{
			attemptUnknownTypeDeserialization = true;
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer)
		{
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeDeserializer(INodeDeserializer nodeDeserializer, Action<IRegistrationLocationSelectionSyntax<INodeDeserializer>> where)
		{
			if (nodeDeserializer == null)
			{
				throw new ArgumentNullException("nodeDeserializer");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateRegistrationLocationSelector(nodeDeserializer.GetType(), (Nothing _) => nodeDeserializer));
			return this;
		}

		public StaticDeserializerBuilder WithNodeDeserializer<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeDeserializer>(WrapperFactory<INodeDeserializer, TNodeDeserializer> nodeDeserializerFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeDeserializer>> where) where TNodeDeserializer : INodeDeserializer
		{
			if (nodeDeserializerFactory == null)
			{
				throw new ArgumentNullException("nodeDeserializerFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeDeserializerFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeDeserializer), (INodeDeserializer wrapped, Nothing _) => nodeDeserializerFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeDeserializer>() where TNodeDeserializer : INodeDeserializer
		{
			return WithoutNodeDeserializer(typeof(TNodeDeserializer));
		}

		public StaticDeserializerBuilder WithoutNodeDeserializer(Type nodeDeserializerType)
		{
			if (nodeDeserializerType == null)
			{
				throw new ArgumentNullException("nodeDeserializerType");
			}
			nodeDeserializerFactories.Remove(nodeDeserializerType);
			return this;
		}

		public StaticDeserializerBuilder WithTypeDiscriminatingNodeDeserializer(Action<ITypeDiscriminatingNodeDeserializerOptions> configureTypeDiscriminatingNodeDeserializerOptions, int maxDepth = -1, int maxLength = -1)
		{
			TypeDiscriminatingNodeDeserializerOptions typeDiscriminatingNodeDeserializerOptions = new TypeDiscriminatingNodeDeserializerOptions();
			configureTypeDiscriminatingNodeDeserializerOptions(typeDiscriminatingNodeDeserializerOptions);
			TypeDiscriminatingNodeDeserializer nodeDeserializer = new TypeDiscriminatingNodeDeserializer(nodeDeserializerFactories.BuildComponentList(), typeDiscriminatingNodeDeserializerOptions.discriminators, maxDepth, maxLength);
			return WithNodeDeserializer(nodeDeserializer, delegate(IRegistrationLocationSelectionSyntax<INodeDeserializer> s)
			{
				s.Before<DictionaryNodeDeserializer>();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver)
		{
			return WithNodeTypeResolver(nodeTypeResolver, delegate(IRegistrationLocationSelectionSyntax<INodeTypeResolver> w)
			{
				w.OnTop();
			});
		}

		public StaticDeserializerBuilder WithNodeTypeResolver(INodeTypeResolver nodeTypeResolver, Action<IRegistrationLocationSelectionSyntax<INodeTypeResolver>> where)
		{
			if (nodeTypeResolver == null)
			{
				throw new ArgumentNullException("nodeTypeResolver");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateRegistrationLocationSelector(nodeTypeResolver.GetType(), (Nothing _) => nodeTypeResolver));
			return this;
		}

		public StaticDeserializerBuilder WithNodeTypeResolver<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeTypeResolver>(WrapperFactory<INodeTypeResolver, TNodeTypeResolver> nodeTypeResolverFactory, Action<ITrackingRegistrationLocationSelectionSyntax<INodeTypeResolver>> where) where TNodeTypeResolver : INodeTypeResolver
		{
			if (nodeTypeResolverFactory == null)
			{
				throw new ArgumentNullException("nodeTypeResolverFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(nodeTypeResolverFactories.CreateTrackingRegistrationLocationSelector(typeof(TNodeTypeResolver), (INodeTypeResolver wrapped, Nothing _) => nodeTypeResolverFactory(wrapped)));
			return this;
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TNodeTypeResolver>() where TNodeTypeResolver : INodeTypeResolver
		{
			return WithoutNodeTypeResolver(typeof(TNodeTypeResolver));
		}

		public StaticDeserializerBuilder WithoutNodeTypeResolver(Type nodeTypeResolverType)
		{
			if (nodeTypeResolverType == null)
			{
				throw new ArgumentNullException("nodeTypeResolverType");
			}
			nodeTypeResolverFactories.Remove(nodeTypeResolverType);
			return this;
		}

		public override StaticDeserializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(tag, out var value))
			{
				throw new ArgumentException($"Type already has a registered type '{value.FullName}' for tag '{tag}'", "tag");
			}
			tagMappings.Add(tag, type);
			return this;
		}

		public StaticDeserializerBuilder WithTypeMapping<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TInterface, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TConcrete>() where TConcrete : TInterface
		{
			Type typeFromHandle = typeof(TInterface);
			Type typeFromHandle2 = typeof(TConcrete);
			if (!typeFromHandle.IsAssignableFrom(typeFromHandle2))
			{
				throw new InvalidOperationException("The type '" + typeFromHandle2.Name + "' does not implement interface '" + typeFromHandle.Name + "'.");
			}
			if (typeMappings.ContainsKey(typeFromHandle))
			{
				typeMappings[typeFromHandle] = typeFromHandle2;
			}
			else
			{
				typeMappings.Add(typeFromHandle, typeFromHandle2);
			}
			return this;
		}

		public StaticDeserializerBuilder WithoutTagMapping(TagName tag)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (!tagMappings.Remove(tag))
			{
				throw new KeyNotFoundException($"Tag '{tag}' is not registered");
			}
			return this;
		}

		public StaticDeserializerBuilder IgnoreUnmatchedProperties()
		{
			ignoreUnmatched = true;
			return this;
		}

		public StaticDeserializerBuilder WithDuplicateKeyChecking()
		{
			duplicateKeyChecking = true;
			return this;
		}

		public IDeserializer Build()
		{
			return Deserializer.FromValueDeserializer(BuildValueDeserializer());
		}

		public IValueDeserializer BuildValueDeserializer()
		{
			return new AliasValueDeserializer(new NodeValueDeserializer(nodeDeserializerFactories.BuildComponentList(), nodeTypeResolverFactories.BuildComponentList(), typeConverter));
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1 })]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class StaticSerializerBuilder : StaticBuilderSkeleton<StaticSerializerBuilder>
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class ValueSerializer : IValueSerializer
		{
			private readonly IObjectGraphTraversalStrategy traversalStrategy;

			private readonly IEventEmitter eventEmitter;

			private readonly IEnumerable<IYamlTypeConverter> typeConverters;

			private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

			private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

			public ValueSerializer(IObjectGraphTraversalStrategy traversalStrategy, IEventEmitter eventEmitter, IEnumerable<IYamlTypeConverter> typeConverters, LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories, LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories)
			{
				this.traversalStrategy = traversalStrategy;
				this.eventEmitter = eventEmitter;
				this.typeConverters = typeConverters;
				this.preProcessingPhaseObjectGraphVisitorFactories = preProcessingPhaseObjectGraphVisitorFactories;
				this.emissionPhaseObjectGraphVisitorFactories = emissionPhaseObjectGraphVisitorFactories;
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			public void SerializeValue([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEmitter emitter, object value, Type type)
			{
				Type type2 = type ?? ((value != null) ? value.GetType() : typeof(object));
				Type staticType = type ?? typeof(object);
				ObjectDescriptor graph = new ObjectDescriptor(value, type2, staticType);
				List<IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitors = preProcessingPhaseObjectGraphVisitorFactories.BuildComponentList(typeConverters);
				foreach (IObjectGraphVisitor<Nothing> item in preProcessingPhaseObjectGraphVisitors)
				{
					traversalStrategy.Traverse(graph, item, default(Nothing));
				}
				IObjectGraphVisitor<IEmitter> visitor = emissionPhaseObjectGraphVisitorFactories.BuildComponentChain(new EmittingObjectGraphVisitor(eventEmitter), [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IObjectGraphVisitor<IEmitter> inner) => new EmissionPhaseObjectGraphVisitorArgs(inner, eventEmitter, preProcessingPhaseObjectGraphVisitors, typeConverters, NestedObjectSerializer));
				traversalStrategy.Traverse(graph, visitor, emitter);
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				void NestedObjectSerializer(object v, Type t)
				{
					SerializeValue(emitter, v, t);
				}
			}
		}

		private readonly StaticContext context;

		private readonly StaticObjectFactory factory;

		private ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory;

		private readonly LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> preProcessingPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>> emissionPhaseObjectGraphVisitorFactories;

		private readonly LazyComponentRegistrationList<IEventEmitter, IEventEmitter> eventEmitterFactories;

		private readonly IDictionary<Type, TagName> tagMappings = new Dictionary<Type, TagName>();

		private int maximumRecursion = 50;

		private EmitterSettings emitterSettings = EmitterSettings.Default;

		private DefaultValuesHandling defaultValuesHandlingConfiguration;

		private bool quoteNecessaryStrings;

		private bool quoteYaml1_1Strings;

		private ScalarStyle defaultScalarStyle;

		protected override StaticSerializerBuilder Self => this;

		public StaticSerializerBuilder(StaticContext context)
			: base((ITypeResolver)new DynamicTypeResolver())
		{
			this.context = context;
			factory = context.GetFactory();
			typeInspectorFactories.Add(typeof(CachedTypeInspector), (ITypeInspector inner) => new CachedTypeInspector(inner));
			typeInspectorFactories.Add(typeof(NamingConventionTypeInspector), (ITypeInspector inner) => (!(namingConvention is NullNamingConvention)) ? new NamingConventionTypeInspector(inner, namingConvention) : inner);
			typeInspectorFactories.Add(typeof(YamlAttributesTypeInspector), (ITypeInspector inner) => new YamlAttributesTypeInspector(inner));
			preProcessingPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<IEnumerable<IYamlTypeConverter>, IObjectGraphVisitor<Nothing>> { 
			{
				typeof(AnchorAssigner),
				(IEnumerable<IYamlTypeConverter> typeConverters) => new AnchorAssigner(typeConverters)
			} };
			emissionPhaseObjectGraphVisitorFactories = new LazyComponentRegistrationList<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>>
			{
				{
					typeof(CustomSerializationObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CustomSerializationObjectGraphVisitor(args.InnerVisitor, args.TypeConverters, args.NestedObjectSerializer)
				},
				{
					typeof(AnchorAssigningObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new AnchorAssigningObjectGraphVisitor(args.InnerVisitor, args.EventEmitter, args.GetPreProcessingPhaseObjectGraphVisitor<AnchorAssigner>())
				},
				{
					typeof(DefaultValuesObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new DefaultValuesObjectGraphVisitor(defaultValuesHandlingConfiguration, args.InnerVisitor, factory)
				},
				{
					typeof(CommentsObjectGraphVisitor),
					(EmissionPhaseObjectGraphVisitorArgs args) => new CommentsObjectGraphVisitor(args.InnerVisitor)
				}
			};
			eventEmitterFactories = new LazyComponentRegistrationList<IEventEmitter, IEventEmitter> { 
			{
				typeof(TypeAssigningEventEmitter),
				(IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: false, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, yamlFormatter)
			} };
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new FullObjectGraphTraversalStrategy(typeInspector, typeResolver, maximumRecursion, namingConvention, factory);
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings(bool quoteYaml1_1Strings = false)
		{
			quoteNecessaryStrings = true;
			this.quoteYaml1_1Strings = quoteYaml1_1Strings;
			return this;
		}

		public StaticSerializerBuilder WithQuotingNecessaryStrings()
		{
			quoteNecessaryStrings = true;
			return this;
		}

		public StaticSerializerBuilder WithDefaultScalarStyle(ScalarStyle style)
		{
			defaultScalarStyle = style;
			return this;
		}

		public StaticSerializerBuilder WithMaximumRecursion(int maximumRecursion)
		{
			if (maximumRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maximumRecursion", $"The maximum recursion specified ({maximumRecursion}) is invalid. It should be a positive integer.");
			}
			this.maximumRecursion = maximumRecursion;
			return this;
		}

		public StaticSerializerBuilder WithEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory) where TEventEmitter : IEventEmitter
		{
			return WithEventEmitter(eventEmitterFactory, delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>(Func<IEventEmitter, TEventEmitter> eventEmitterFactory, Action<IRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter inner) => eventEmitterFactory(inner)));
			return Self;
		}

		public StaticSerializerBuilder WithEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>(WrapperFactory<IEventEmitter, IEventEmitter, TEventEmitter> eventEmitterFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IEventEmitter>> where) where TEventEmitter : IEventEmitter
		{
			if (eventEmitterFactory == null)
			{
				throw new ArgumentNullException("eventEmitterFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(eventEmitterFactories.CreateTrackingRegistrationLocationSelector(typeof(TEventEmitter), (IEventEmitter wrapped, IEventEmitter inner) => eventEmitterFactory(wrapped, inner)));
			return Self;
		}

		public StaticSerializerBuilder WithoutEventEmitter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TEventEmitter>() where TEventEmitter : IEventEmitter
		{
			return WithoutEventEmitter(typeof(TEventEmitter));
		}

		public StaticSerializerBuilder WithoutEventEmitter(Type eventEmitterType)
		{
			if (eventEmitterType == null)
			{
				throw new ArgumentNullException("eventEmitterType");
			}
			eventEmitterFactories.Remove(eventEmitterType);
			return this;
		}

		public override StaticSerializerBuilder WithTagMapping(TagName tag, Type type)
		{
			if (tag.IsEmpty)
			{
				throw new ArgumentException("Non-specific tags cannot be maped");
			}
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (tagMappings.TryGetValue(type, out var value))
			{
				throw new ArgumentException($"Type already has a registered tag '{value}' for type '{type.FullName}'", "type");
			}
			tagMappings.Add(type, tag);
			return this;
		}

		public StaticSerializerBuilder WithoutTagMapping(Type type)
		{
			if (type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (!tagMappings.Remove(type))
			{
				throw new KeyNotFoundException("Tag for type '" + type.FullName + "' is not registered");
			}
			return this;
		}

		public StaticSerializerBuilder EnsureRoundtrip()
		{
			objectGraphTraversalStrategyFactory = (ITypeInspector typeInspector, ITypeResolver typeResolver, IEnumerable<IYamlTypeConverter> typeConverters, int maximumRecursion) => new RoundtripObjectGraphTraversalStrategy(typeConverters, typeInspector, typeResolver, maximumRecursion, namingConvention, settings, factory);
			WithEventEmitter([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] ([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEventEmitter inner) => new TypeAssigningEventEmitter(inner, requireTagWhenStaticAndActualTypesAreDifferent: true, tagMappings, quoteNecessaryStrings), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
			return WithTypeInspector([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] ([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] ITypeInspector inner) => new ReadableAndWritablePropertiesTypeInspector(inner), delegate(IRegistrationLocationSelectionSyntax<ITypeInspector> loc)
			{
				loc.OnBottom();
			});
		}

		public StaticSerializerBuilder DisableAliases()
		{
			preProcessingPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigner));
			emissionPhaseObjectGraphVisitorFactories.Remove(typeof(AnchorAssigningObjectGraphVisitor));
			return this;
		}

		[Obsolete("The default behavior is now to always emit default values, thefore calling this method has no effect. This behavior is now controlled by ConfigureDefaultValuesHandling.", true)]
		public StaticSerializerBuilder EmitDefaults()
		{
			return ConfigureDefaultValuesHandling(DefaultValuesHandling.Preserve);
		}

		public StaticSerializerBuilder ConfigureDefaultValuesHandling(DefaultValuesHandling configuration)
		{
			defaultValuesHandlingConfiguration = configuration;
			return this;
		}

		public StaticSerializerBuilder JsonCompatible()
		{
			emitterSettings = emitterSettings.WithMaxSimpleKeyLength(int.MaxValue).WithoutAnchorName();
			return WithTypeConverter(new YamlDotNet.Serialization.Converters.GuidConverter(jsonCompatible: true), delegate(IRegistrationLocationSelectionSyntax<IYamlTypeConverter> w)
			{
				w.InsteadOf<YamlDotNet.Serialization.Converters.GuidConverter>();
			}).WithTypeConverter(new YamlDotNet.Serialization.Converters.DateTimeConverter(DateTimeKind.Utc, null, true)).WithEventEmitter([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] ([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] IEventEmitter inner) => new JsonEventEmitter(inner, yamlFormatter), delegate(IRegistrationLocationSelectionSyntax<IEventEmitter> loc)
			{
				loc.InsteadOf<TypeAssigningEventEmitter>();
			});
		}

		public StaticSerializerBuilder WithNewLine(string newLine)
		{
			emitterSettings = emitterSettings.WithNewLine(newLine);
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithPreProcessingPhaseObjectGraphVisitor(objectGraphVisitor, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(TObjectGraphVisitor objectGraphVisitor, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitor == null)
			{
				throw new ArgumentNullException("objectGraphVisitor");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IEnumerable<IYamlTypeConverter> _) => objectGraphVisitor));
			return this;
		}

		public StaticSerializerBuilder WithPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<IObjectGraphVisitor<Nothing>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<Nothing>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(preProcessingPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<Nothing> wrapped, IEnumerable<IYamlTypeConverter> _) => objectGraphVisitorFactory(wrapped)));
			return this;
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<Nothing>
		{
			return WithoutPreProcessingPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutPreProcessingPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			preProcessingPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithObjectGraphTraversalStrategyFactory(ObjectGraphTraversalStrategyFactory objectGraphTraversalStrategyFactory)
		{
			this.objectGraphTraversalStrategyFactory = objectGraphTraversalStrategyFactory;
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithEmissionPhaseObjectGraphVisitor(objectGraphVisitorFactory, delegate(IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>> w)
			{
				w.OnTop();
			});
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(Func<EmissionPhaseObjectGraphVisitorArgs, TObjectGraphVisitor> objectGraphVisitorFactory, Action<IRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateRegistrationLocationSelector(typeof(TObjectGraphVisitor), (EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(args)));
			return this;
		}

		public StaticSerializerBuilder WithEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>(WrapperFactory<EmissionPhaseObjectGraphVisitorArgs, IObjectGraphVisitor<IEmitter>, TObjectGraphVisitor> objectGraphVisitorFactory, Action<ITrackingRegistrationLocationSelectionSyntax<IObjectGraphVisitor<IEmitter>>> where) where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			if (objectGraphVisitorFactory == null)
			{
				throw new ArgumentNullException("objectGraphVisitorFactory");
			}
			if (where == null)
			{
				throw new ArgumentNullException("where");
			}
			where(emissionPhaseObjectGraphVisitorFactories.CreateTrackingRegistrationLocationSelector(typeof(TObjectGraphVisitor), (IObjectGraphVisitor<IEmitter> wrapped, EmissionPhaseObjectGraphVisitorArgs args) => objectGraphVisitorFactory(wrapped, args)));
			return this;
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TObjectGraphVisitor>() where TObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
		{
			return WithoutEmissionPhaseObjectGraphVisitor(typeof(TObjectGraphVisitor));
		}

		public StaticSerializerBuilder WithoutEmissionPhaseObjectGraphVisitor(Type objectGraphVisitorType)
		{
			if (objectGraphVisitorType == null)
			{
				throw new ArgumentNullException("objectGraphVisitorType");
			}
			emissionPhaseObjectGraphVisitorFactories.Remove(objectGraphVisitorType);
			return this;
		}

		public StaticSerializerBuilder WithIndentedSequences()
		{
			emitterSettings = emitterSettings.WithIndentedSequences();
			return this;
		}

		public ISerializer Build()
		{
			return Serializer.FromValueSerializer(BuildValueSerializer(), emitterSettings);
		}

		public IValueSerializer BuildValueSerializer()
		{
			IEnumerable<IYamlTypeConverter> typeConverters = BuildTypeConverters();
			ITypeInspector typeInspector = BuildTypeInspector();
			IObjectGraphTraversalStrategy traversalStrategy = objectGraphTraversalStrategyFactory(typeInspector, typeResolver, typeConverters, maximumRecursion);
			IEventEmitter eventEmitter = eventEmitterFactories.BuildComponentChain(new WriterEventEmitter());
			return new ValueSerializer(traversalStrategy, eventEmitter, typeConverters, preProcessingPhaseObjectGraphVisitorFactories.Clone(), emissionPhaseObjectGraphVisitorFactories.Clone());
		}

		internal ITypeInspector BuildTypeInspector()
		{
			ITypeInspector typeInspector = context.GetTypeInspector();
			return typeInspectorFactories.BuildComponentChain(typeInspector);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class StreamFragment : IYamlConvertible
	{
		private readonly List<ParsingEvent> events = new List<ParsingEvent>();

		public IList<ParsingEvent> Events => events;

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			events.Clear();
			int num = 0;
			do
			{
				if (!parser.MoveNext())
				{
					throw new InvalidOperationException("The parser has reached the end before deserialization completed.");
				}
				ParsingEvent current = parser.Current;
				events.Add(current);
				num += current.NestingIncrease;
			}
			while (num > 0);
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			foreach (ParsingEvent @event in events)
			{
				emitter.Emit(@event);
			}
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class TagMappings
	{
		private readonly IDictionary<string, Type> mappings;

		public TagMappings()
		{
			mappings = new Dictionary<string, Type>();
		}

		public TagMappings(IDictionary<string, Type> mappings)
		{
			this.mappings = new Dictionary<string, Type>(mappings);
		}

		public void Add(string tag, Type mapping)
		{
			mappings.Add(tag, mapping);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		internal Type GetMapping(string tag)
		{
			if (!mappings.TryGetValue(tag, out var value))
			{
				return null;
			}
			return value;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class YamlAttributeOverrides
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private struct AttributeKey
		{
			public readonly Type AttributeType;

			public readonly string PropertyName;

			public AttributeKey(Type attributeType, string propertyName)
			{
				AttributeType = attributeType;
				PropertyName = propertyName;
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			public override bool Equals(object obj)
			{
				if (obj is AttributeKey attributeKey && AttributeType.Equals(attributeKey.AttributeType))
				{
					return PropertyName.Equals(attributeKey.PropertyName);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(AttributeType.GetHashCode(), PropertyName.GetHashCode());
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private sealed class AttributeMapping
		{
			public readonly Type RegisteredType;

			public readonly Attribute Attribute;

			public AttributeMapping(Type registeredType, Attribute attribute)
			{
				RegisteredType = registeredType;
				Attribute = attribute;
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			public override bool Equals(object obj)
			{
				if (obj is AttributeMapping attributeMapping && RegisteredType.Equals(attributeMapping.RegisteredType))
				{
					return Attribute.Equals(attributeMapping.Attribute);
				}
				return false;
			}

			public override int GetHashCode()
			{
				return YamlDotNet.Core.HashCode.CombineHashCodes(RegisteredType.GetHashCode(), Attribute.GetHashCode());
			}

			public int Matches(Type matchType)
			{
				int num = 0;
				Type type = matchType;
				while (type != null)
				{
					num++;
					if (type == RegisteredType)
					{
						return num;
					}
					type = type.BaseType();
				}
				if (matchType.GetInterfaces().Contains(RegisteredType))
				{
					return num;
				}
				return 0;
			}
		}

		private readonly Dictionary<AttributeKey, List<AttributeMapping>> overrides = new Dictionary<AttributeKey, List<AttributeMapping>>();

		[return: MaybeNull]
		public T GetAttribute<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(Type type, string member) where T : Attribute
		{
			if (overrides.TryGetValue(new AttributeKey(typeof(T), member), out var value))
			{
				int num = 0;
				AttributeMapping attributeMapping = null;
				foreach (AttributeMapping item in value)
				{
					int num2 = item.Matches(type);
					if (num2 > num)
					{
						num = num2;
						attributeMapping = item;
					}
				}
				if (num > 0)
				{
					return (T)attributeMapping.Attribute;
				}
			}
			return null;
		}

		public void Add(Type type, string member, Attribute attribute)
		{
			AttributeMapping item = new AttributeMapping(type, attribute);
			AttributeKey key = new AttributeKey(attribute.GetType(), member);
			if (!overrides.TryGetValue(key, out var value))
			{
				value = new List<AttributeMapping>();
				overrides.Add(key, value);
			}
			else if (value.Contains(item))
			{
				throw new InvalidOperationException($"Attribute ({attribute}) already set for Type {type.FullName}, Member {member}");
			}
			value.Add(item);
		}

		public YamlAttributeOverrides Clone()
		{
			YamlAttributeOverrides yamlAttributeOverrides = new YamlAttributeOverrides();
			foreach (KeyValuePair<AttributeKey, List<AttributeMapping>> @override in overrides)
			{
				foreach (AttributeMapping item in @override.Value)
				{
					yamlAttributeOverrides.Add(item.RegisteredType, @override.Key.PropertyName, item.Attribute);
				}
			}
			return yamlAttributeOverrides;
		}

		public void Add<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TClass>(Expression<Func<TClass, object>> propertyAccessor, Attribute attribute)
		{
			PropertyInfo propertyInfo = propertyAccessor.AsProperty();
			Add(typeof(TClass), propertyInfo.Name, attribute);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class YamlAttributeOverridesInspector : TypeInspectorSkeleton
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		public sealed class OverridePropertyDescriptor : IPropertyDescriptor
		{
			private readonly IPropertyDescriptor baseDescriptor;

			private readonly YamlAttributeOverrides overrides;

			private readonly Type classType;

			public string Name => baseDescriptor.Name;

			public bool CanWrite => baseDescriptor.CanWrite;

			public Type Type => baseDescriptor.Type;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public Type TypeOverride
			{
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				get
				{
					return baseDescriptor.TypeOverride;
				}
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				set
				{
					baseDescriptor.TypeOverride = value;
				}
			}

			public int Order
			{
				get
				{
					return baseDescriptor.Order;
				}
				set
				{
					baseDescriptor.Order = value;
				}
			}

			public ScalarStyle ScalarStyle
			{
				get
				{
					return baseDescriptor.ScalarStyle;
				}
				set
				{
					baseDescriptor.ScalarStyle = value;
				}
			}

			public OverridePropertyDescriptor(IPropertyDescriptor baseDescriptor, YamlAttributeOverrides overrides, Type classType)
			{
				this.baseDescriptor = baseDescriptor;
				this.overrides = overrides;
				this.classType = classType;
			}

			public void Write(object target, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value)
			{
				baseDescriptor.Write(target, value);
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
			[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return overrides.GetAttribute<T>(classType, Name) ?? baseDescriptor.GetCustomAttribute<T>();
			}

			public IObjectDescriptor Read(object target)
			{
				return baseDescriptor.Read(target);
			}
		}

		private readonly ITypeInspector innerTypeDescriptor;

		private readonly YamlAttributeOverrides overrides;

		public YamlAttributeOverridesInspector(ITypeInspector innerTypeDescriptor, YamlAttributeOverrides overrides)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
			this.overrides = overrides;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			IEnumerable<IPropertyDescriptor> enumerable = innerTypeDescriptor.GetProperties(type, container);
			if (overrides != null)
			{
				enumerable = enumerable.Select((Func<IPropertyDescriptor, IPropertyDescriptor>)([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IPropertyDescriptor p) => new OverridePropertyDescriptor(p, overrides, type)));
			}
			return enumerable;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class YamlAttributesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public YamlAttributesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return from p in (from p in innerTypeDescriptor.GetProperties(type, container)
					where p.GetCustomAttribute<YamlIgnoreAttribute>() == null
					select p).Select((Func<IPropertyDescriptor, IPropertyDescriptor>)([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IPropertyDescriptor p) =>
				{
					PropertyDescriptor propertyDescriptor = new PropertyDescriptor(p);
					YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
					if (customAttribute != null)
					{
						if (customAttribute.SerializeAs != null)
						{
							propertyDescriptor.TypeOverride = customAttribute.SerializeAs;
						}
						propertyDescriptor.Order = customAttribute.Order;
						propertyDescriptor.ScalarStyle = customAttribute.ScalarStyle;
						if (customAttribute.Alias != null)
						{
							propertyDescriptor.Name = customAttribute.Alias;
						}
					}
					return propertyDescriptor;
				}))
				orderby p.Order
				select p;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class YamlFormatter
	{
		public static YamlFormatter Default { get; } = new YamlFormatter();


		public NumberFormatInfo NumberFormat { get; set; } = new NumberFormatInfo
		{
			CurrencyDecimalSeparator = ".",
			CurrencyGroupSeparator = "_",
			CurrencyGroupSizes = new int[1] { 3 },
			CurrencySymbol = string.Empty,
			CurrencyDecimalDigits = 99,
			NumberDecimalSeparator = ".",
			NumberGroupSeparator = "_",
			NumberGroupSizes = new int[1] { 3 },
			NumberDecimalDigits = 99,
			NaNSymbol = ".nan",
			PositiveInfinitySymbol = ".inf",
			NegativeInfinitySymbol = "-.inf"
		};


		public string FormatNumber(object number)
		{
			return Convert.ToString(number, NumberFormat);
		}

		public string FormatNumber(double number)
		{
			return number.ToString("G", NumberFormat);
		}

		public string FormatNumber(float number)
		{
			return number.ToString("G", NumberFormat);
		}

		public string FormatBoolean(object boolean)
		{
			if (!boolean.Equals(true))
			{
				return "false";
			}
			return "true";
		}

		public string FormatDateTime(object dateTime)
		{
			return ((DateTime)dateTime).ToString("o", CultureInfo.InvariantCulture);
		}

		public string FormatTimeSpan(object timeSpan)
		{
			return ((TimeSpan)timeSpan).ToString();
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlIgnoreAttribute : Attribute
	{
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class YamlMemberAttribute : Attribute
	{
		private DefaultValuesHandling? defaultValuesHandling;

		public string Description { get; set; }

		public Type SerializeAs { get; set; }

		public int Order { get; set; }

		public string Alias { get; set; }

		public bool ApplyNamingConventions { get; set; }

		public ScalarStyle ScalarStyle { get; set; }

		public DefaultValuesHandling DefaultValuesHandling
		{
			get
			{
				return defaultValuesHandling.GetValueOrDefault();
			}
			set
			{
				defaultValuesHandling = value;
			}
		}

		public bool IsDefaultValuesHandlingSpecified => defaultValuesHandling.HasValue;

		public YamlMemberAttribute()
		{
			ScalarStyle = ScalarStyle.Any;
			ApplyNamingConventions = true;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public YamlMemberAttribute(Type serializeAs)
			: this()
		{
			SerializeAs = serializeAs ?? throw new ArgumentNullException("serializeAs");
		}
	}
	[AttributeUsage(AttributeTargets.Class, Inherited = false, AllowMultiple = true)]
	internal sealed class YamlSerializableAttribute : Attribute
	{
		public YamlSerializableAttribute()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public YamlSerializableAttribute(Type serializableType)
		{
		}
	}
	internal sealed class YamlStaticContextAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.ValueDeserializers
{
	internal sealed class AliasValueDeserializer : IValueDeserializer
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1 })]
		private sealed class AliasState : Dictionary<AnchorName, ValuePromise>, IPostDeserializationCallback
		{
			public void OnDeserialization()
			{
				foreach (ValuePromise value in base.Values)
				{
					if (!value.HasValue)
					{
						YamlDotNet.Core.Events.AnchorAlias alias = value.Alias;
						Mark start = alias.Start;
						Mark end = alias.End;
						throw new AnchorNotFoundException(ref start, ref end, $"Anchor '{alias.Value}' not found");
					}
				}
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private sealed class ValuePromise : IValuePromise
		{
			private object value;

			public readonly YamlDotNet.Core.Events.AnchorAlias Alias;

			public bool HasValue { get; private set; }

			public object Value
			{
				get
				{
					if (!HasValue)
					{
						throw new InvalidOperationException("Value not set");
					}
					return value;
				}
				set
				{
					if (HasValue)
					{
						throw new InvalidOperationException("Value already set");
					}
					HasValue = true;
					this.value = value;
					this.ValueAvailable?.Invoke(value);
				}
			}

			public event Action<object> ValueAvailable;

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			public ValuePromise(YamlDotNet.Core.Events.AnchorAlias alias)
			{
				Alias = alias;
			}

			public ValuePromise(object value)
			{
				HasValue = true;
				this.value = value;
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		private readonly IValueDeserializer innerDeserializer;

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public AliasValueDeserializer(IValueDeserializer innerDeserializer)
		{
			this.innerDeserializer = innerDeserializer ?? throw new ArgumentNullException("innerDeserializer");
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var @event))
			{
				if (!state.Get<AliasState>().TryGetValue(@event.Value, out var value))
				{
					Mark start = @event.Start;
					Mark end = @event.End;
					throw new AnchorNotFoundException(ref start, ref end, $"Alias ${@event.Value} cannot precede anchor declaration");
				}
				if (!value.HasValue)
				{
					return value;
				}
				return value.Value;
			}
			AnchorName anchorName = AnchorName.Empty;
			if (parser.Accept<NodeEvent>(out var event2) && !event2.Anchor.IsEmpty)
			{
				anchorName = event2.Anchor;
				AliasState aliasState = state.Get<AliasState>();
				if (!aliasState.ContainsKey(anchorName))
				{
					aliasState[anchorName] = new ValuePromise(new YamlDotNet.Core.Events.AnchorAlias(anchorName));
				}
			}
			object obj = innerDeserializer.DeserializeValue(parser, expectedType, state, nestedObjectDeserializer);
			if (!anchorName.IsEmpty)
			{
				AliasState aliasState2 = state.Get<AliasState>();
				if (!aliasState2.TryGetValue(anchorName, out var value2))
				{
					aliasState2.Add(anchorName, new ValuePromise(obj));
				}
				else if (!value2.HasValue)
				{
					value2.Value = obj;
				}
				else
				{
					aliasState2[anchorName] = new ValuePromise(obj);
				}
			}
			return obj;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class NodeValueDeserializer : IValueDeserializer
	{
		private readonly IList<INodeDeserializer> deserializers;

		private readonly IList<INodeTypeResolver> typeResolvers;

		private readonly ITypeConverter typeConverter;

		public NodeValueDeserializer(IList<INodeDeserializer> deserializers, IList<INodeTypeResolver> typeResolvers, ITypeConverter typeConverter)
		{
			this.deserializers = deserializers ?? throw new ArgumentNullException("deserializers");
			this.typeResolvers = typeResolvers ?? throw new ArgumentNullException("typeResolvers");
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object DeserializeValue(IParser parser, Type expectedType, SerializerState state, IValueDeserializer nestedObjectDeserializer)
		{
			parser.Accept<NodeEvent>(out var @event);
			Type typeFromEvent = GetTypeFromEvent(@event, expectedType);
			Mark start;
			Mark end;
			try
			{
				foreach (INodeDeserializer deserializer in deserializers)
				{
					if (deserializer.Deserialize(parser, typeFromEvent, [return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] (IParser r, Type t) => nestedObjectDeserializer.DeserializeValue(r, t, state, nestedObjectDeserializer), out var value))
					{
						return typeConverter.ChangeType(value, expectedType);
					}
				}
			}
			catch (YamlException)
			{
				throw;
			}
			catch (Exception innerException)
			{
				start = @event?.Start ?? Mark.Empty;
				end = @event?.End ?? Mark.Empty;
				throw new YamlException(ref start, ref end, "Exception during deserialization", innerException);
			}
			start = @event?.Start ?? Mark.Empty;
			end = @event?.End ?? Mark.Empty;
			throw new YamlException(ref start, ref end, "No node deserializer was able to deserialize the node into type " + expectedType.AssemblyQualifiedName);
		}

		private Type GetTypeFromEvent([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, Type currentType)
		{
			using (IEnumerator<INodeTypeResolver> enumerator = typeResolvers.GetEnumerator())
			{
				while (enumerator.MoveNext() && !enumerator.Current.Resolve(nodeEvent, ref currentType))
				{
				}
			}
			return currentType;
		}
	}
}
namespace YamlDotNet.Serialization.Utilities
{
	internal interface IPostDeserializationCallback
	{
		void OnDeserialization();
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	internal interface ITypeConverter
	{
		object ChangeType(object value, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] Type expectedType);
	}
	internal class NullTypeConverter : ITypeConverter
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public object ChangeType(object value, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] Type expectedType)
		{
			return value;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class ObjectAnchorCollection
	{
		private readonly IDictionary<string, object> objectsByAnchor = new Dictionary<string, object>();

		private readonly IDictionary<object, string> anchorsByObject = new Dictionary<object, string>();

		public object this[string anchor]
		{
			get
			{
				if (objectsByAnchor.TryGetValue(anchor, out var value))
				{
					return value;
				}
				throw new AnchorNotFoundException("The anchor '" + anchor + "' does not exists");
			}
		}

		public void Add(string anchor, object @object)
		{
			objectsByAnchor.Add(anchor, @object);
			if (@object != null)
			{
				anchorsByObject.Add(@object, anchor);
			}
		}

		public bool TryGetAnchor(object @object, [MaybeNullWhen(false)][<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out string anchor)
		{
			return anchorsByObject.TryGetValue(@object, out anchor);
		}
	}
	internal class ReflectionTypeConverter : ITypeConverter
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public object ChangeType(object value, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] Type expectedType)
		{
			return TypeConverter.ChangeType(value, expectedType);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal static class ReflectionUtility
	{
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static Type GetImplementedGenericInterface(Type type, Type genericInterfaceType)
		{
			foreach (Type implementedInterface in GetImplementedInterfaces(type))
			{
				if (implementedInterface.IsGenericType() && implementedInterface.GetGenericTypeDefinition() == genericInterfaceType)
				{
					return implementedInterface;
				}
			}
			return null;
		}

		public static IEnumerable<Type> GetImplementedInterfaces(Type type)
		{
			if (type.IsInterface())
			{
				yield return type;
			}
			Type[] interfaces = type.GetInterfaces();
			for (int i = 0; i < interfaces.Length; i++)
			{
				yield return interfaces[i];
			}
		}
	}
	internal sealed class SerializerState : IDisposable
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		private readonly IDictionary<Type, object> items = new Dictionary<Type, object>();

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public T Get<T>() where T : class, new()
		{
			if (!items.TryGetValue(typeof(T), out var value))
			{
				value = new T();
				items.Add(typeof(T), value);
			}
			return (T)value;
		}

		public void OnDeserialization()
		{
			foreach (IPostDeserializationCallback item in items.Values.OfType<IPostDeserializationCallback>())
			{
				item.OnDeserialization();
			}
		}

		public void Dispose()
		{
			foreach (IDisposable item in items.Values.OfType<IDisposable>())
			{
				item.Dispose();
			}
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal static class StringExtensions
	{
		private static string ToCamelOrPascalCase(string str, Func<char, char> firstLetterTransform)
		{
			string text = Regex.Replace(str, "([_\\-])(?<char>[a-z])", [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (Match match) => match.Groups["char"].Value.ToUpperInvariant(), RegexOptions.IgnoreCase);
			return firstLetterTransform(text[0]) + text.Substring(1);
		}

		public static string ToCamelCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToLowerInvariant);
		}

		public static string ToPascalCase(this string str)
		{
			return ToCamelOrPascalCase(str, char.ToUpperInvariant);
		}

		public static string FromCamelCase(this string str, string separator)
		{
			str = char.ToLower(str[0]) + str.Substring(1);
			str = Regex.Replace(str.ToCamelCase(), "(?<char>[A-Z])", [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (Match match) => separator + match.Groups["char"].Value.ToLowerInvariant());
			return str;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal static class TypeConverter
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static T ChangeType<T>(object value)
		{
			return (T)ChangeType(value, typeof(T));
		}

		public static T ChangeType<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, IFormatProvider provider)
		{
			return (T)ChangeType(value, typeof(T), provider);
		}

		public static T ChangeType<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, CultureInfo culture)
		{
			return (T)ChangeType(value, typeof(T), culture);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public static object ChangeType(object value, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] Type destinationType)
		{
			return ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static object ChangeType([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type destinationType, IFormatProvider provider)
		{
			return ChangeType(value, destinationType, new CultureInfoAdapter(CultureInfo.CurrentCulture, provider));
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static object ChangeType([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type destinationType, CultureInfo culture)
		{
			if (value == null || value.IsDbNull())
			{
				if (!destinationType.IsValueType())
				{
					return null;
				}
				return Activator.CreateInstance(destinationType);
			}
			Type type = value.GetType();
			if (destinationType == type || destinationType.IsAssignableFrom(type))
			{
				return value;
			}
			if (destinationType.IsGenericType() && destinationType.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				Type destinationType2 = destinationType.GetGenericArguments()[0];
				object obj = ChangeType(value, destinationType2, culture);
				return Activator.CreateInstance(destinationType, obj);
			}
			if (destinationType.IsEnum())
			{
				if (!(value is string value2))
				{
					return value;
				}
				return Enum.Parse(destinationType, value2, ignoreCase: true);
			}
			if (destinationType == typeof(bool))
			{
				if ("0".Equals(value))
				{
					return false;
				}
				if ("1".Equals(value))
				{
					return true;
				}
			}
			System.ComponentModel.TypeConverter converter = TypeDescriptor.GetConverter(type);
			if (converter != null && converter.CanConvertTo(destinationType))
			{
				return converter.ConvertTo(null, culture, value, destinationType);
			}
			System.ComponentModel.TypeConverter converter2 = TypeDescriptor.GetConverter(destinationType);
			if (converter2 != null && converter2.CanConvertFrom(type))
			{
				return converter2.ConvertFrom(null, culture, value);
			}
			Type[] array = new Type[2] { type, destinationType };
			for (int i = 0; i < array.Length; i++)
			{
				foreach (MethodInfo publicStaticMethod2 in array[i].GetPublicStaticMethods())
				{
					if (!publicStaticMethod2.IsSpecialName || (!(publicStaticMethod2.Name == "op_Implicit") && !(publicStaticMethod2.Name == "op_Explicit")) || !destinationType.IsAssignableFrom(publicStaticMethod2.ReturnParameter.ParameterType))
					{
						continue;
					}
					ParameterInfo[] parameters = publicStaticMethod2.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType.IsAssignableFrom(type))
					{
						try
						{
							return publicStaticMethod2.Invoke(null, new object[1] { value });
						}
						catch (TargetInvocationException ex)
						{
							throw ex.Unwrap();
						}
					}
				}
			}
			if (type == typeof(string))
			{
				try
				{
					MethodInfo publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string), typeof(IFormatProvider));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[2] { value, culture });
					}
					publicStaticMethod = destinationType.GetPublicStaticMethod("Parse", typeof(string));
					if (publicStaticMethod != null)
					{
						return publicStaticMethod.Invoke(null, new object[1] { value });
					}
				}
				catch (TargetInvocationException ex2)
				{
					throw ex2.Unwrap();
				}
			}
			if (destinationType == typeof(TimeSpan))
			{
				return TimeSpan.Parse((string)ChangeType(value, typeof(string), CultureInfo.InvariantCulture));
			}
			return Convert.ChangeType(value, destinationType, CultureInfo.InvariantCulture);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		public static void RegisterTypeConverter<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TConvertible, TConverter>() where TConverter : System.ComponentModel.TypeConverter
		{
			if (!TypeDescriptor.GetAttributes(typeof(TConvertible)).OfType<TypeConverterAttribute>().Any([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (TypeConverterAttribute a) => a.ConverterTypeName == typeof(TConverter).AssemblyQualifiedName))
			{
				TypeDescriptor.AddAttributes(typeof(TConvertible), new TypeConverterAttribute(typeof(TConverter)));
			}
		}
	}
}
namespace YamlDotNet.Serialization.TypeResolvers
{
	internal sealed class DynamicTypeResolver : ITypeResolver
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public Type Resolve(Type staticType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object actualValue)
		{
			if (actualValue == null)
			{
				return staticType;
			}
			return actualValue.GetType();
		}
	}
	internal class StaticTypeResolver : ITypeResolver
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public virtual Type Resolve(Type staticType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object actualValue)
		{
			if (actualValue != null)
			{
				if (actualValue.GetType().IsEnum)
				{
					return staticType;
				}
				switch (actualValue.GetType().GetTypeCode())
				{
				case TypeCode.Boolean:
					return typeof(bool);
				case TypeCode.Char:
					return typeof(char);
				case TypeCode.SByte:
					return typeof(sbyte);
				case TypeCode.Byte:
					return typeof(byte);
				case TypeCode.Int16:
					return typeof(short);
				case TypeCode.UInt16:
					return typeof(ushort);
				case TypeCode.Int32:
					return typeof(int);
				case TypeCode.UInt32:
					return typeof(uint);
				case TypeCode.Int64:
					return typeof(long);
				case TypeCode.UInt64:
					return typeof(ulong);
				case TypeCode.Single:
					return typeof(float);
				case TypeCode.Double:
					return typeof(double);
				case TypeCode.Decimal:
					return typeof(decimal);
				case TypeCode.String:
					return typeof(string);
				case TypeCode.DateTime:
					return typeof(DateTime);
				}
			}
			return staticType;
		}
	}
}
namespace YamlDotNet.Serialization.TypeInspectors
{
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class CachedTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly ConcurrentDictionary<Type, List<IPropertyDescriptor>> cache = new ConcurrentDictionary<Type, List<IPropertyDescriptor>>();

		public CachedTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return cache.GetOrAdd(type, (Type t) => innerTypeDescriptor.GetProperties(t, container).ToList());
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class CompositeTypeInspector : TypeInspectorSkeleton
	{
		private readonly IEnumerable<ITypeInspector> typeInspectors;

		public CompositeTypeInspector(params ITypeInspector[] typeInspectors)
			: this((IEnumerable<ITypeInspector>)typeInspectors)
		{
		}

		public CompositeTypeInspector(IEnumerable<ITypeInspector> typeInspectors)
		{
			this.typeInspectors = typeInspectors?.ToList() ?? throw new ArgumentNullException("typeInspectors");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return typeInspectors.SelectMany([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (ITypeInspector i) => i.GetProperties(type, container));
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class NamingConventionTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		private readonly INamingConvention namingConvention;

		public NamingConventionTypeInspector(ITypeInspector innerTypeDescriptor, INamingConvention namingConvention)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return innerTypeDescriptor.GetProperties(type, container).Select([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IPropertyDescriptor p) =>
			{
				YamlMemberAttribute customAttribute = p.GetCustomAttribute<YamlMemberAttribute>();
				return (customAttribute != null && !customAttribute.ApplyNamingConventions) ? p : new PropertyDescriptor(p)
				{
					Name = namingConvention.Apply(p.Name)
				};
			});
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class ReadableAndWritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		private readonly ITypeInspector innerTypeDescriptor;

		public ReadableAndWritablePropertiesTypeInspector(ITypeInspector innerTypeDescriptor)
		{
			this.innerTypeDescriptor = innerTypeDescriptor ?? throw new ArgumentNullException("innerTypeDescriptor");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return from p in innerTypeDescriptor.GetProperties(type, container)
				where p.CanWrite
				select p;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class ReadableFieldsTypeInspector : TypeInspectorSkeleton
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private sealed class ReflectionFieldDescriptor : IPropertyDescriptor
		{
			private readonly FieldInfo fieldInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => fieldInfo.Name;

			public Type Type => fieldInfo.FieldType;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			[field: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public Type TypeOverride
			{
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				get;
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => !fieldInfo.IsInitOnly;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionFieldDescriptor(FieldInfo fieldInfo, ITypeResolver typeResolver)
			{
				this.fieldInfo = fieldInfo;
				this.typeResolver = typeResolver;
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value)
			{
				fieldInfo.SetValue(target, value);
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
			[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return (T)fieldInfo.GetCustomAttributes(typeof(T), inherit: true).FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object value = fieldInfo.GetValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, value);
				return new ObjectDescriptor(value, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		public ReadableFieldsTypeInspector(ITypeResolver typeResolver)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return type.GetPublicFields().Select((Func<FieldInfo, IPropertyDescriptor>)([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (FieldInfo p) => new ReflectionFieldDescriptor(p, typeResolver)));
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class ReadablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			[field: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public Type TypeOverride
			{
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				get;
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
			[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return (T)propertyInfo.GetAllCustomAttributes<T>().FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public ReadablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanRead)
			{
				return property.GetGetMethod(nonPublic: true).GetParameters().Length == 0;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)));
		}
	}
	internal abstract class TypeInspectorSkeleton : ITypeInspector
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public abstract IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container);

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public IPropertyDescriptor GetProperty(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container, string name, [MaybeNullWhen(true)] bool ignoreUnmatched)
		{
			IEnumerable<IPropertyDescriptor> enumerable = from p in GetProperties(type, container)
				where p.Name == name
				select p;
			using IEnumerator<IPropertyDescriptor> enumerator = enumerable.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				if (ignoreUnmatched)
				{
					return null;
				}
				throw new SerializationException("Property '" + name + "' not found on type '" + type.FullName + "'.");
			}
			IPropertyDescriptor current = enumerator.Current;
			if (enumerator.MoveNext())
			{
				throw new SerializationException("Multiple properties with the name/alias '" + name + "' already exists on type '" + type.FullName + "', maybe you're misusing YamlAlias or maybe you are using the wrong naming convention? The matching properties are: " + string.Join(", ", enumerable.Select((IPropertyDescriptor p) => p.Name).ToArray()));
			}
			return current;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class WritablePropertiesTypeInspector : TypeInspectorSkeleton
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private sealed class ReflectionPropertyDescriptor : IPropertyDescriptor
		{
			private readonly PropertyInfo propertyInfo;

			private readonly ITypeResolver typeResolver;

			public string Name => propertyInfo.Name;

			public Type Type => propertyInfo.PropertyType;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			[field: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public Type TypeOverride
			{
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				get;
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				set;
			}

			public int Order { get; set; }

			public bool CanWrite => propertyInfo.CanWrite;

			public ScalarStyle ScalarStyle { get; set; }

			public ReflectionPropertyDescriptor(PropertyInfo propertyInfo, ITypeResolver typeResolver)
			{
				this.propertyInfo = propertyInfo ?? throw new ArgumentNullException("propertyInfo");
				this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
				ScalarStyle = ScalarStyle.Any;
			}

			public void Write(object target, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value)
			{
				propertyInfo.SetValue(target, value, null);
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
			[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public T GetCustomAttribute<T>() where T : Attribute
			{
				return (T)propertyInfo.GetAllCustomAttributes<T>().FirstOrDefault();
			}

			public IObjectDescriptor Read(object target)
			{
				object obj = propertyInfo.ReadValue(target);
				Type type = TypeOverride ?? typeResolver.Resolve(Type, obj);
				return new ObjectDescriptor(obj, type, Type, ScalarStyle);
			}
		}

		private readonly ITypeResolver typeResolver;

		private readonly bool includeNonPublicProperties;

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver)
			: this(typeResolver, includeNonPublicProperties: false)
		{
		}

		public WritablePropertiesTypeInspector(ITypeResolver typeResolver, bool includeNonPublicProperties)
		{
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.includeNonPublicProperties = includeNonPublicProperties;
		}

		private static bool IsValidProperty(PropertyInfo property)
		{
			if (property.CanWrite)
			{
				return property.GetSetMethod(nonPublic: true).GetParameters().Length == 1;
			}
			return false;
		}

		public override IEnumerable<IPropertyDescriptor> GetProperties(Type type, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object container)
		{
			return type.GetProperties(includeNonPublicProperties).Where(IsValidProperty).Select((Func<PropertyInfo, IPropertyDescriptor>)([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (PropertyInfo p) => new ReflectionPropertyDescriptor(p, typeResolver)))
				.ToArray();
		}
	}
}
namespace YamlDotNet.Serialization.Schemas
{
	internal sealed class FailsafeSchema
	{
		public static class Tags
		{
			public static readonly TagName Map = new TagName("tag:yaml.org,2002:map");

			public static readonly TagName Seq = new TagName("tag:yaml.org,2002:seq");

			public static readonly TagName Str = new TagName("tag:yaml.org,2002:str");
		}
	}
	internal sealed class JsonSchema
	{
		public static class Tags
		{
			public static readonly TagName Null = new TagName("tag:yaml.org,2002:null");

			public static readonly TagName Bool = new TagName("tag:yaml.org,2002:bool");

			public static readonly TagName Int = new TagName("tag:yaml.org,2002:int");

			public static readonly TagName Float = new TagName("tag:yaml.org,2002:float");
		}
	}
	internal sealed class CoreSchema
	{
		public static class Tags
		{
		}
	}
	internal sealed class DefaultSchema
	{
		public static class Tags
		{
			public static readonly TagName Timestamp = new TagName("tag:yaml.org,2002:timestamp");
		}
	}
}
namespace YamlDotNet.Serialization.ObjectGraphVisitors
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class AnchorAssigner : PreProcessingPhaseObjectGraphVisitorSkeleton, IAliasProvider
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		private class AnchorAssignment
		{
			public AnchorName Anchor;
		}

		private readonly IDictionary<object, AnchorAssignment> assignments = new Dictionary<object, AnchorAssignment>();

		private uint nextId;

		public AnchorAssigner(IEnumerable<IYamlTypeConverter> typeConverters)
			: base(typeConverters)
		{
		}

		protected override bool Enter(IObjectDescriptor value)
		{
			if (value.Value != null && assignments.TryGetValue(value.Value, out var value2))
			{
				if (value2.Anchor.IsEmpty)
				{
					value2.Anchor = new AnchorName("o" + nextId.ToString(CultureInfo.InvariantCulture));
					nextId++;
				}
				return false;
			}
			return true;
		}

		protected override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value)
		{
			return true;
		}

		protected override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value)
		{
			return true;
		}

		protected override void VisitScalar(IObjectDescriptor scalar)
		{
		}

		protected override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType)
		{
			VisitObject(mapping);
		}

		protected override void VisitMappingEnd(IObjectDescriptor mapping)
		{
		}

		protected override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType)
		{
			VisitObject(sequence);
		}

		protected override void VisitSequenceEnd(IObjectDescriptor sequence)
		{
		}

		private void VisitObject(IObjectDescriptor value)
		{
			if (value.Value != null)
			{
				assignments.Add(value.Value, new AnchorAssignment());
			}
		}

		AnchorName IAliasProvider.GetAlias(object target)
		{
			if (target != null && assignments.TryGetValue(target, out var value))
			{
				return value.Anchor;
			}
			return AnchorName.Empty;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class AnchorAssigningObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEventEmitter eventEmitter;

		private readonly IAliasProvider aliasProvider;

		private readonly HashSet<AnchorName> emittedAliases = new HashSet<AnchorName>();

		public AnchorAssigningObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEventEmitter eventEmitter, IAliasProvider aliasProvider)
			: base(nextVisitor)
		{
			this.eventEmitter = eventEmitter;
			this.aliasProvider = aliasProvider;
		}

		public override bool Enter(IObjectDescriptor value, IEmitter context)
		{
			if (value.Value != null)
			{
				AnchorName alias = aliasProvider.GetAlias(value.Value);
				if (!alias.IsEmpty && !emittedAliases.Add(alias))
				{
					AliasEventInfo aliasEventInfo = new AliasEventInfo(value, alias);
					eventEmitter.Emit(aliasEventInfo, context);
					return aliasEventInfo.NeedsExpansion;
				}
			}
			return base.Enter(value, context);
		}

		public override void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
		{
			AnchorName alias = aliasProvider.GetAlias(mapping.NonNullValue());
			eventEmitter.Emit(new MappingStartEventInfo(mapping)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
		{
			AnchorName alias = aliasProvider.GetAlias(sequence.NonNullValue());
			eventEmitter.Emit(new SequenceStartEventInfo(sequence)
			{
				Anchor = alias
			}, context);
		}

		public override void VisitScalar(IObjectDescriptor scalar, IEmitter context)
		{
			ScalarEventInfo scalarEventInfo = new ScalarEventInfo(scalar);
			if (scalar.Value != null)
			{
				scalarEventInfo.Anchor = aliasProvider.GetAlias(scalar.Value);
			}
			eventEmitter.Emit(scalarEventInfo, context);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal abstract class ChainedObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IObjectGraphVisitor<IEmitter> nextVisitor;

		protected ChainedObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
		{
			this.nextVisitor = nextVisitor;
		}

		public virtual bool Enter(IObjectDescriptor value, IEmitter context)
		{
			return nextVisitor.Enter(value, context);
		}

		public virtual bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return nextVisitor.EnterMapping(key, value, context);
		}

		public virtual void VisitScalar(IObjectDescriptor scalar, IEmitter context)
		{
			nextVisitor.VisitScalar(scalar, context);
		}

		public virtual void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
		{
			nextVisitor.VisitMappingStart(mapping, keyType, valueType, context);
		}

		public virtual void VisitMappingEnd(IObjectDescriptor mapping, IEmitter context)
		{
			nextVisitor.VisitMappingEnd(mapping, context);
		}

		public virtual void VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
		{
			nextVisitor.VisitSequenceStart(sequence, elementType, context);
		}

		public virtual void VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context)
		{
			nextVisitor.VisitSequenceEnd(sequence, context);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class CommentsObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public CommentsObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.Description != null)
			{
				context.Emit(new YamlDotNet.Core.Events.Comment(customAttribute.Description, isInline: false));
			}
			return base.EnterMapping(key, value, context);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class CustomSerializationObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly IEnumerable<IYamlTypeConverter> typeConverters;

		private readonly ObjectSerializer nestedObjectSerializer;

		public CustomSerializationObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor, IEnumerable<IYamlTypeConverter> typeConverters, ObjectSerializer nestedObjectSerializer)
			: base(nextVisitor)
		{
			IEnumerable<IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
			this.nestedObjectSerializer = nestedObjectSerializer;
		}

		public override bool Enter(IObjectDescriptor value, IEmitter context)
		{
			IYamlTypeConverter yamlTypeConverter = typeConverters.FirstOrDefault([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IYamlTypeConverter t) => t.Accepts(value.Type));
			if (yamlTypeConverter != null)
			{
				yamlTypeConverter.WriteYaml(context, value.Value, value.Type);
				return false;
			}
			if (value.Value is IYamlConvertible yamlConvertible)
			{
				yamlConvertible.Write(context, nestedObjectSerializer);
				return false;
			}
			if (value.Value is IYamlSerializable yamlSerializable)
			{
				yamlSerializable.WriteYaml(context);
				return false;
			}
			return base.Enter(value, context);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class DefaultExclusiveObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		public DefaultExclusiveObjectGraphVisitor(IObjectGraphVisitor<IEmitter> nextVisitor)
			: base(nextVisitor)
		{
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private static object GetDefault(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public override bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			if (!object.Equals(value.Value, GetDefault(value.Type)))
			{
				return base.EnterMapping(key, value, context);
			}
			return false;
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			DefaultValueAttribute customAttribute = key.GetCustomAttribute<DefaultValueAttribute>();
			object objB = ((customAttribute != null) ? customAttribute.Value : GetDefault(key.Type));
			if (!object.Equals(value.Value, objB))
			{
				return base.EnterMapping(key, value, context);
			}
			return false;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class DefaultValuesObjectGraphVisitor : ChainedObjectGraphVisitor
	{
		private readonly DefaultValuesHandling handling;

		private readonly IObjectFactory factory;

		public DefaultValuesObjectGraphVisitor(DefaultValuesHandling handling, IObjectGraphVisitor<IEmitter> nextVisitor, IObjectFactory factory)
			: base(nextVisitor)
		{
			this.handling = handling;
			this.factory = factory;
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private object GetDefault(Type type)
		{
			return factory.CreatePrimitive(type);
		}

		public override bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			DefaultValuesHandling defaultValuesHandling = handling;
			YamlMemberAttribute customAttribute = key.GetCustomAttribute<YamlMemberAttribute>();
			if (customAttribute != null && customAttribute.IsDefaultValuesHandlingSpecified)
			{
				defaultValuesHandling = customAttribute.DefaultValuesHandling;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitNull) != 0 && value.Value == null)
			{
				return false;
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitEmptyCollections) != 0 && value.Value is IEnumerable enumerable)
			{
				IEnumerator enumerator = enumerable.GetEnumerator();
				bool flag = enumerator.MoveNext();
				if (enumerator is IDisposable disposable)
				{
					disposable.Dispose();
				}
				if (!flag)
				{
					return false;
				}
			}
			if ((defaultValuesHandling & DefaultValuesHandling.OmitDefaults) != 0)
			{
				object objB = key.GetCustomAttribute<DefaultValueAttribute>()?.Value ?? GetDefault(key.Type);
				if (object.Equals(value.Value, objB))
				{
					return false;
				}
			}
			return base.EnterMapping(key, value, context);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class EmittingObjectGraphVisitor : IObjectGraphVisitor<IEmitter>
	{
		private readonly IEventEmitter eventEmitter;

		public EmittingObjectGraphVisitor(IEventEmitter eventEmitter)
		{
			this.eventEmitter = eventEmitter;
		}

		bool IObjectGraphVisitor<IEmitter>.Enter(IObjectDescriptor value, IEmitter context)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return true;
		}

		bool IObjectGraphVisitor<IEmitter>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, IEmitter context)
		{
			return true;
		}

		void IObjectGraphVisitor<IEmitter>.VisitScalar(IObjectDescriptor scalar, IEmitter context)
		{
			eventEmitter.Emit(new ScalarEventInfo(scalar), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, IEmitter context)
		{
			eventEmitter.Emit(new MappingStartEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitMappingEnd(IObjectDescriptor mapping, IEmitter context)
		{
			eventEmitter.Emit(new MappingEndEventInfo(mapping), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, IEmitter context)
		{
			eventEmitter.Emit(new SequenceStartEventInfo(sequence), context);
		}

		void IObjectGraphVisitor<IEmitter>.VisitSequenceEnd(IObjectDescriptor sequence, IEmitter context)
		{
			eventEmitter.Emit(new SequenceEndEventInfo(sequence), context);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal abstract class PreProcessingPhaseObjectGraphVisitorSkeleton : IObjectGraphVisitor<Nothing>
	{
		protected readonly IEnumerable<IYamlTypeConverter> typeConverters;

		public PreProcessingPhaseObjectGraphVisitorSkeleton(IEnumerable<IYamlTypeConverter> typeConverters)
		{
			IEnumerable<IYamlTypeConverter> enumerable;
			if (typeConverters == null)
			{
				enumerable = Enumerable.Empty<IYamlTypeConverter>();
			}
			else
			{
				IEnumerable<IYamlTypeConverter> enumerable2 = typeConverters.ToList();
				enumerable = enumerable2;
			}
			this.typeConverters = enumerable;
		}

		bool IObjectGraphVisitor<Nothing>.Enter(IObjectDescriptor value, Nothing context)
		{
			if (typeConverters.FirstOrDefault([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IYamlTypeConverter t) => t.Accepts(value.Type)) != null)
			{
				return false;
			}
			if (value.Value is IYamlConvertible)
			{
				return false;
			}
			if (value.Value is IYamlSerializable)
			{
				return false;
			}
			return Enter(value);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IPropertyDescriptor key, IObjectDescriptor value, Nothing context)
		{
			return EnterMapping(key, value);
		}

		bool IObjectGraphVisitor<Nothing>.EnterMapping(IObjectDescriptor key, IObjectDescriptor value, Nothing context)
		{
			return EnterMapping(key, value);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingEnd(IObjectDescriptor mapping, Nothing context)
		{
			VisitMappingEnd(mapping);
		}

		void IObjectGraphVisitor<Nothing>.VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType, Nothing context)
		{
			VisitMappingStart(mapping, keyType, valueType);
		}

		void IObjectGraphVisitor<Nothing>.VisitScalar(IObjectDescriptor scalar, Nothing context)
		{
			VisitScalar(scalar);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceEnd(IObjectDescriptor sequence, Nothing context)
		{
			VisitSequenceEnd(sequence);
		}

		void IObjectGraphVisitor<Nothing>.VisitSequenceStart(IObjectDescriptor sequence, Type elementType, Nothing context)
		{
			VisitSequenceStart(sequence, elementType);
		}

		protected abstract bool Enter(IObjectDescriptor value);

		protected abstract bool EnterMapping(IPropertyDescriptor key, IObjectDescriptor value);

		protected abstract bool EnterMapping(IObjectDescriptor key, IObjectDescriptor value);

		protected abstract void VisitMappingEnd(IObjectDescriptor mapping);

		protected abstract void VisitMappingStart(IObjectDescriptor mapping, Type keyType, Type valueType);

		protected abstract void VisitScalar(IObjectDescriptor scalar);

		protected abstract void VisitSequenceEnd(IObjectDescriptor sequence);

		protected abstract void VisitSequenceStart(IObjectDescriptor sequence, Type elementType);
	}
}
namespace YamlDotNet.Serialization.ObjectGraphTraversalStrategies
{
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class FullObjectGraphTraversalStrategy : IObjectGraphTraversalStrategy
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		protected struct ObjectPathSegment
		{
			public readonly object Name;

			public readonly IObjectDescriptor Value;

			public ObjectPathSegment(object name, IObjectDescriptor value)
			{
				Name = name;
				Value = value;
			}
		}

		private readonly int maxRecursion;

		private readonly ITypeInspector typeDescriptor;

		private readonly ITypeResolver typeResolver;

		private readonly INamingConvention namingConvention;

		private readonly IObjectFactory objectFactory;

		public FullObjectGraphTraversalStrategy(ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, IObjectFactory objectFactory)
		{
			if (maxRecursion <= 0)
			{
				throw new ArgumentOutOfRangeException("maxRecursion", maxRecursion, "maxRecursion must be greater than 1");
			}
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.typeResolver = typeResolver ?? throw new ArgumentNullException("typeResolver");
			this.maxRecursion = maxRecursion;
			this.namingConvention = namingConvention ?? throw new ArgumentNullException("namingConvention");
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		void IObjectGraphTraversalStrategy.Traverse<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(IObjectDescriptor graph, IObjectGraphVisitor<TContext> visitor, TContext context)
		{
			Traverse("<root>", graph, visitor, context, new Stack<ObjectPathSegment>(maxRecursion));
		}

		protected virtual void Traverse<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(object name, IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (path.Count >= maxRecursion)
			{
				StringBuilder stringBuilder = new StringBuilder();
				stringBuilder.AppendLine("Too much recursion when traversing the object graph.");
				stringBuilder.AppendLine("The path to reach this recursion was:");
				Stack<KeyValuePair<string, string>> stack = new Stack<KeyValuePair<string, string>>(path.Count);
				int num = 0;
				foreach (ObjectPathSegment item in path)
				{
					string text = item.Name?.ToString() ?? string.Empty;
					num = Math.Max(num, text.Length);
					stack.Push(new KeyValuePair<string, string>(text, item.Value.Type.FullName));
				}
				foreach (KeyValuePair<string, string> item2 in stack)
				{
					stringBuilder.Append(" -> ").Append(item2.Key.PadRight(num)).Append("  [")
						.Append(item2.Value)
						.AppendLine("]");
				}
				throw new MaximumRecursionLevelReachedException(stringBuilder.ToString());
			}
			if (!visitor.Enter(value, context))
			{
				return;
			}
			path.Push(new ObjectPathSegment(name, value));
			try
			{
				TypeCode typeCode = value.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
				case TypeCode.Char:
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
				case TypeCode.DateTime:
				case TypeCode.String:
					visitor.VisitScalar(value, context);
					return;
				case TypeCode.Empty:
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
				if (value.IsDbNull())
				{
					visitor.VisitScalar(new ObjectDescriptor(null, typeof(object), typeof(object)), context);
				}
				if (value.Value == null || value.Type == typeof(TimeSpan))
				{
					visitor.VisitScalar(value, context);
					return;
				}
				Type underlyingType = Nullable.GetUnderlyingType(value.Type);
				if (underlyingType != null)
				{
					Traverse("Value", new ObjectDescriptor(value.Value, underlyingType, value.Type, value.ScalarStyle), visitor, context, path);
				}
				else
				{
					TraverseObject(value, visitor, context, path);
				}
			}
			finally
			{
				path.Pop();
			}
		}

		protected virtual void TraverseObject<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			IDictionary dictionary;
			Type[] genericArguments;
			if (typeof(IDictionary).IsAssignableFrom(value.Type))
			{
				TraverseDictionary(value, visitor, typeof(object), typeof(object), context, path);
			}
			else if (objectFactory.GetDictionary(value, out dictionary, out genericArguments))
			{
				TraverseDictionary(new ObjectDescriptor(dictionary, value.Type, value.StaticType, value.ScalarStyle), visitor, genericArguments[0], genericArguments[1], context, path);
			}
			else if (typeof(IEnumerable).IsAssignableFrom(value.Type))
			{
				TraverseList(value, visitor, context, path);
			}
			else
			{
				TraverseProperties(value, visitor, context, path);
			}
		}

		protected virtual void TraverseDictionary<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(IObjectDescriptor dictionary, IObjectGraphVisitor<TContext> visitor, Type keyType, Type valueType, TContext context, Stack<ObjectPathSegment> path)
		{
			visitor.VisitMappingStart(dictionary, keyType, valueType, context);
			bool flag = dictionary.Type.FullName.Equals("System.Dynamic.ExpandoObject");
			foreach (DictionaryEntry? item in (IDictionary)dictionary.NonNullValue())
			{
				DictionaryEntry value = item.Value;
				object obj = (flag ? namingConvention.Apply(value.Key.ToString()) : value.Key);
				IObjectDescriptor objectDescriptor = GetObjectDescriptor(obj, keyType);
				IObjectDescriptor objectDescriptor2 = GetObjectDescriptor(value.Value, valueType);
				if (visitor.EnterMapping(objectDescriptor, objectDescriptor2, context))
				{
					Traverse(obj, objectDescriptor, visitor, context, path);
					Traverse(obj, objectDescriptor2, visitor, context, path);
				}
			}
			visitor.VisitMappingEnd(dictionary, context);
		}

		private void TraverseList<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			Type valueType = objectFactory.GetValueType(value.Type);
			visitor.VisitSequenceStart(value, valueType, context);
			int num = 0;
			foreach (object item in (IEnumerable)value.NonNullValue())
			{
				Traverse(num, GetObjectDescriptor(item, valueType), visitor, context, path);
				num++;
			}
			visitor.VisitSequenceEnd(value, context);
		}

		protected virtual void TraverseProperties<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerializing(value.Value);
			}
			visitor.VisitMappingStart(value, typeof(string), typeof(object), context);
			object obj = value.NonNullValue();
			foreach (IPropertyDescriptor property in typeDescriptor.GetProperties(value.Type, obj))
			{
				IObjectDescriptor value2 = property.Read(obj);
				if (visitor.EnterMapping(property, value2, context))
				{
					Traverse(property.Name, new ObjectDescriptor(property.Name, typeof(string), typeof(string), ScalarStyle.Plain), visitor, context, path);
					Traverse(property.Name, value2, visitor, context, path);
				}
			}
			visitor.VisitMappingEnd(value, context);
			if (context.GetType() != typeof(Nothing))
			{
				objectFactory.ExecuteOnSerialized(value.Value);
			}
		}

		private IObjectDescriptor GetObjectDescriptor([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type staticType)
		{
			return new ObjectDescriptor(value, typeResolver.Resolve(staticType, value), staticType);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class RoundtripObjectGraphTraversalStrategy : FullObjectGraphTraversalStrategy
	{
		private readonly IEnumerable<IYamlTypeConverter> converters;

		private readonly Settings settings;

		public RoundtripObjectGraphTraversalStrategy(IEnumerable<IYamlTypeConverter> converters, ITypeInspector typeDescriptor, ITypeResolver typeResolver, int maxRecursion, INamingConvention namingConvention, Settings settings, IObjectFactory factory)
			: base(typeDescriptor, typeResolver, maxRecursion, namingConvention, factory)
		{
			this.converters = converters;
			this.settings = settings;
		}

		protected override void TraverseProperties<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TContext>(IObjectDescriptor value, IObjectGraphVisitor<TContext> visitor, TContext context, Stack<ObjectPathSegment> path)
		{
			if (!value.Type.HasDefaultConstructor(settings.AllowPrivateConstructors) && !converters.Any([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IYamlTypeConverter c) => c.Accepts(value.Type)))
			{
				throw new InvalidOperationException($"Type '{value.Type}' cannot be deserialized because it does not have a default constructor or a type converter.");
			}
			base.TraverseProperties(value, visitor, context, path);
		}
	}
}
namespace YamlDotNet.Serialization.ObjectFactories
{
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class DefaultObjectFactory : ObjectFactoryBase
	{
		private readonly Dictionary<Type, Dictionary<Type, MethodInfo[]>> _stateMethods = new Dictionary<Type, Dictionary<Type, MethodInfo[]>>
		{
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute),
				new Dictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute),
				new Dictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute),
				new Dictionary<Type, MethodInfo[]>()
			},
			{
				typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute),
				new Dictionary<Type, MethodInfo[]>()
			}
		};

		private readonly Dictionary<Type, Type> DefaultGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable<>),
				typeof(List<>)
			},
			{
				typeof(ICollection<>),
				typeof(List<>)
			},
			{
				typeof(IList<>),
				typeof(List<>)
			},
			{
				typeof(IDictionary<, >),
				typeof(Dictionary<, >)
			}
		};

		private readonly Dictionary<Type, Type> DefaultNonGenericInterfaceImplementations = new Dictionary<Type, Type>
		{
			{
				typeof(IEnumerable),
				typeof(List<object>)
			},
			{
				typeof(ICollection),
				typeof(List<object>)
			},
			{
				typeof(IList),
				typeof(List<object>)
			},
			{
				typeof(IDictionary),
				typeof(Dictionary<object, object>)
			}
		};

		private readonly Settings settings;

		public DefaultObjectFactory()
			: this(new Dictionary<Type, Type>(), new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings)
			: this(mappings, new Settings())
		{
		}

		public DefaultObjectFactory(IDictionary<Type, Type> mappings, Settings settings)
		{
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
				DefaultNonGenericInterfaceImplementations.Add(mapping.Key, mapping.Value);
			}
			this.settings = settings;
		}

		public override object Create(Type type)
		{
			if (type.IsInterface())
			{
				Type value2;
				if (type.IsGenericType())
				{
					if (DefaultGenericInterfaceImplementations.TryGetValue(type.GetGenericTypeDefinition(), out var value))
					{
						type = value.MakeGenericType(type.GetGenericArguments());
					}
				}
				else if (DefaultNonGenericInterfaceImplementations.TryGetValue(type, out value2))
				{
					type = value2;
				}
			}
			try
			{
				return Activator.CreateInstance(type, settings.AllowPrivateConstructors);
			}
			catch (Exception innerException)
			{
				throw new InvalidOperationException("Failed to create an instance of type '" + type.FullName + "'.", innerException);
			}
		}

		public override void ExecuteOnDeserialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializedAttribute), value);
		}

		public override void ExecuteOnDeserializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnDeserializingAttribute), value);
		}

		public override void ExecuteOnSerialized(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializedAttribute), value);
		}

		public override void ExecuteOnSerializing(object value)
		{
			ExecuteState(typeof(YamlDotNet.Serialization.Callbacks.OnSerializingAttribute), value);
		}

		private void ExecuteState(Type attributeType, object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				MethodInfo[] stateMethods = GetStateMethods(attributeType, type);
				for (int i = 0; i < stateMethods.Length; i++)
				{
					stateMethods[i].Invoke(value, null);
				}
			}
		}

		private MethodInfo[] GetStateMethods(Type attributeType, Type valueType)
		{
			Dictionary<Type, MethodInfo[]> dictionary = _stateMethods[attributeType];
			if (dictionary.TryGetValue(valueType, out var value))
			{
				return value;
			}
			value = valueType.GetMethods(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			return dictionary[valueType] = value.Where([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (MethodInfo x) => x.GetCustomAttributes(attributeType, inherit: true).Any()).ToArray();
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class LambdaObjectFactory : ObjectFactoryBase
	{
		private readonly Func<Type, object> factory;

		public LambdaObjectFactory(Func<Type, object> factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public override object Create(Type type)
		{
			return factory(type);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal abstract class ObjectFactoryBase : IObjectFactory
	{
		public abstract object Create(Type type);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public virtual object CreatePrimitive(Type type)
		{
			if (!type.IsValueType())
			{
				return null;
			}
			return Activator.CreateInstance(type);
		}

		public virtual void ExecuteOnDeserialized(object value)
		{
		}

		public virtual void ExecuteOnDeserializing(object value)
		{
		}

		public virtual void ExecuteOnSerialized(object value)
		{
		}

		public virtual void ExecuteOnSerializing(object value)
		{
		}

		public virtual bool GetDictionary(IObjectDescriptor descriptor, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out IDictionary dictionary, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments)
		{
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(descriptor.Type, typeof(IDictionary<, >));
			if (implementedGenericInterface != null)
			{
				genericArguments = implementedGenericInterface.GetGenericArguments();
				object obj = Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(genericArguments), descriptor.Value);
				dictionary = obj as IDictionary;
				return true;
			}
			genericArguments = null;
			dictionary = null;
			return false;
		}

		public virtual Type GetValueType(Type type)
		{
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(type, typeof(IEnumerable<>));
			if (!(implementedGenericInterface != null))
			{
				return typeof(object);
			}
			return implementedGenericInterface.GetGenericArguments()[0];
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal abstract class StaticObjectFactory : IObjectFactory
	{
		public abstract object Create(Type type);

		public abstract Array CreateArray(Type type, int count);

		public abstract bool IsDictionary(Type type);

		public abstract bool IsArray(Type type);

		public abstract bool IsList(Type type);

		public abstract Type GetKeyType(Type type);

		public abstract Type GetValueType(Type type);

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public virtual object CreatePrimitive(Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Boolean => false, 
				TypeCode.Byte => (byte)0, 
				TypeCode.Int16 => (short)0, 
				TypeCode.Int32 => 0, 
				TypeCode.Int64 => 0L, 
				TypeCode.SByte => (sbyte)0, 
				TypeCode.UInt16 => (ushort)0, 
				TypeCode.UInt32 => 0u, 
				TypeCode.UInt64 => 0uL, 
				TypeCode.Single => 0f, 
				TypeCode.Double => 0.0, 
				TypeCode.Decimal => 0m, 
				TypeCode.Char => '\0', 
				TypeCode.DateTime => default(DateTime), 
				_ => null, 
			};
		}

		public bool GetDictionary(IObjectDescriptor descriptor, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out IDictionary dictionary, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })] out Type[] genericArguments)
		{
			dictionary = null;
			genericArguments = null;
			return false;
		}

		public abstract void ExecuteOnDeserializing(object value);

		public abstract void ExecuteOnDeserialized(object value);

		public abstract void ExecuteOnSerializing(object value);

		public abstract void ExecuteOnSerialized(object value);
	}
}
namespace YamlDotNet.Serialization.NodeTypeResolvers
{
	internal sealed class DefaultContainersNodeTypeResolver : INodeTypeResolver
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (currentType == typeof(object))
			{
				if (nodeEvent is SequenceStart)
				{
					currentType = typeof(List<object>);
					return true;
				}
				if (nodeEvent is MappingStart)
				{
					currentType = typeof(Dictionary<object, object>);
					return true;
				}
			}
			return false;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class MappingNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<Type, Type> _mappings;

		public MappingNodeTypeResolver(IDictionary<Type, Type> mappings)
		{
			if (mappings == null)
			{
				throw new ArgumentNullException("mappings");
			}
			foreach (KeyValuePair<Type, Type> mapping in mappings)
			{
				if (!mapping.Key.IsAssignableFrom(mapping.Value))
				{
					throw new InvalidOperationException($"Type '{mapping.Value}' does not implement type '{mapping.Key}'.");
				}
			}
			_mappings = mappings;
		}

		public bool Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (_mappings.TryGetValue(currentType, out var value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	internal class PreventUnknownTagsNodeTypeResolver : INodeTypeResolver
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Mark start = nodeEvent.Start;
				Mark end = nodeEvent.End;
				throw new YamlException(ref start, ref end, $"Encountered an unresolved tag '{nodeEvent.Tag}'");
			}
			return false;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class TagNodeTypeResolver : INodeTypeResolver
	{
		private readonly IDictionary<TagName, Type> tagMappings;

		public TagNodeTypeResolver(IDictionary<TagName, Type> tagMappings)
		{
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
		}

		bool INodeTypeResolver.Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty && tagMappings.TryGetValue(nodeEvent.Tag, out var value))
			{
				currentType = value;
				return true;
			}
			return false;
		}
	}
	[Obsolete("The mechanism that this class uses to specify type names is non-standard. Register the tags explicitly instead of using this convention.")]
	internal sealed class TypeNameInTagNodeTypeResolver : INodeTypeResolver
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		bool INodeTypeResolver.Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			if (nodeEvent != null && !nodeEvent.Tag.IsEmpty)
			{
				Type type = Type.GetType(nodeEvent.Tag.Value.Substring(1), throwOnError: false);
				if (type != null)
				{
					currentType = type;
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class YamlConvertibleTypeResolver : INodeTypeResolver
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public bool Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(IYamlConvertible).IsAssignableFrom(currentType);
		}
	}
	internal sealed class YamlSerializableTypeResolver : INodeTypeResolver
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public bool Resolve([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] NodeEvent nodeEvent, ref Type currentType)
		{
			return typeof(IYamlSerializable).IsAssignableFrom(currentType);
		}
	}
}
namespace YamlDotNet.Serialization.NodeDeserializers
{
	internal sealed class ArrayNodeDeserializer : INodeDeserializer
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 2 })]
			private object[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
			public object SyncRoot
			{
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
				get
				{
					return data;
				}
			}

			public ArrayList()
			{
				Clear();
			}

			public int Add(object value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (!expectedType.IsArray)
			{
				value = false;
				return false;
			}
			Type? elementType = expectedType.GetElementType();
			ArrayList arrayList = new ArrayList();
			CollectionNodeDeserializer.DeserializeHelper(elementType, parser, nestedObjectDeserializer, arrayList, canUpdate: true);
			Array array = Array.CreateInstance(elementType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	internal abstract class CollectionDeserializer
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		protected static void DeserializeHelper(Type tItem, IParser parser, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate, IObjectFactory objectFactory)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(ref start, ref end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(objectFactory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class CollectionNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public CollectionNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			bool canUpdate = true;
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(ICollection<>));
			Type type;
			IList list;
			if (implementedGenericInterface != null)
			{
				type = implementedGenericInterface.GetGenericArguments()[0];
				value = objectFactory.Create(expectedType);
				list = value as IList;
				if (list == null)
				{
					canUpdate = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IList<>)) != null;
					list = (IList)Activator.CreateInstance(typeof(GenericCollectionToNonGenericAdapter<>).MakeGenericType(type), value);
				}
			}
			else
			{
				if (!typeof(IList).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				value = objectFactory.Create(expectedType);
				list = (IList)value;
			}
			DeserializeHelper(type, parser, nestedObjectDeserializer, list, canUpdate);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, IList result, bool canUpdate)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				ParsingEvent current = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					if (!canUpdate)
					{
						Mark start = current?.Start ?? Mark.Empty;
						Mark end = current?.End ?? Mark.Empty;
						throw new ForwardAnchorNotSupportedException(ref start, ref end, "Forward alias references are not allowed because this type does not implement IList<>");
					}
					int index = result.Add(tItem.IsValueType() ? Activator.CreateInstance(tItem) : null);
					valuePromise.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
					{
						result[index] = YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(v, tItem);
					};
				}
				else
				{
					result.Add(YamlDotNet.Serialization.Utilities.TypeConverter.ChangeType(obj, tItem));
				}
			}
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal abstract class DictionaryDeserializer
	{
		private readonly bool duplicateKeyChecking;

		public DictionaryDeserializer(bool duplicateKeyChecking)
		{
			this.duplicateKeyChecking = duplicateKeyChecking;
		}

		private void TryAssign(IDictionary result, object key, object value, MappingStart propertyName)
		{
			if (duplicateKeyChecking && result.Contains(key))
			{
				Mark start = propertyName.Start;
				Mark end = propertyName.End;
				throw new YamlException(ref start, ref end, $"Encountered duplicate key {key}");
			}
			result[key] = value;
		}

		protected virtual void Deserialize(Type tKey, Type tValue, IParser parser, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, IDictionary result)
		{
			MappingStart property = parser.Consume<MappingStart>();
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				object key = nestedObjectDeserializer(parser, tKey);
				object value = nestedObjectDeserializer(parser, tValue);
				IValuePromise valuePromise = value as IValuePromise;
				if (key is IValuePromise valuePromise2)
				{
					if (valuePromise == null)
					{
						valuePromise2.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
						{
							result[v] = value;
						};
						continue;
					}
					bool hasFirstPart = false;
					valuePromise2.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							TryAssign(result, v, value, property);
						}
						else
						{
							key = v;
							hasFirstPart = true;
						}
					};
					valuePromise.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
					{
						if (hasFirstPart)
						{
							TryAssign(result, key, v, property);
						}
						else
						{
							value = v;
							hasFirstPart = true;
						}
					};
					continue;
				}
				if (key == null)
				{
					throw new ArgumentException("Empty key names are not supported yet.", "key");
				}
				if (valuePromise == null)
				{
					TryAssign(result, key, value, property);
					continue;
				}
				valuePromise.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
				{
					result[key] = v;
				};
			}
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class DictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public DictionaryNodeDeserializer(IObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IDictionary<, >));
			Type type;
			Type type2;
			IDictionary dictionary;
			if (implementedGenericInterface != null)
			{
				Type[] genericArguments = implementedGenericInterface.GetGenericArguments();
				type = genericArguments[0];
				type2 = genericArguments[1];
				value = objectFactory.Create(expectedType);
				dictionary = value as IDictionary;
				if (dictionary == null)
				{
					dictionary = (IDictionary)Activator.CreateInstance(typeof(GenericDictionaryToNonGenericAdapter<, >).MakeGenericType(type, type2), value);
				}
			}
			else
			{
				if (!typeof(IDictionary).IsAssignableFrom(expectedType))
				{
					value = null;
					return false;
				}
				type = typeof(object);
				type2 = typeof(object);
				value = objectFactory.Create(expectedType);
				dictionary = (IDictionary)value;
			}
			Deserialize(type, type2, parser, nestedObjectDeserializer, dictionary);
			return true;
		}
	}
	internal sealed class EnumerableNodeDeserializer : INodeDeserializer
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			Type type;
			if (expectedType == typeof(IEnumerable))
			{
				type = typeof(object);
			}
			else
			{
				Type implementedGenericInterface = ReflectionUtility.GetImplementedGenericInterface(expectedType, typeof(IEnumerable<>));
				if (implementedGenericInterface != expectedType)
				{
					value = null;
					return false;
				}
				type = implementedGenericInterface.GetGenericArguments()[0];
			}
			Type arg = typeof(List<>).MakeGenericType(type);
			value = nestedObjectDeserializer(parser, arg);
			return true;
		}
	}
	internal sealed class NullNodeDeserializer : INodeDeserializer
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			value = null;
			if (parser.Accept<NodeEvent>(out var @event) && NodeIsNull(@event))
			{
				parser.SkipThisAndNestedEvents();
				return true;
			}
			return false;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		private bool NodeIsNull(NodeEvent nodeEvent)
		{
			if (nodeEvent.Tag == "tag:yaml.org,2002:null")
			{
				return true;
			}
			if (nodeEvent is YamlDotNet.Core.Events.Scalar scalar && scalar.Style == ScalarStyle.Plain && !scalar.IsKey)
			{
				string value = scalar.Value;
				switch (value)
				{
				default:
					return value == "NULL";
				case "":
				case "~":
				case "null":
				case "Null":
					return true;
				}
			}
			return false;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class ObjectNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		private readonly ITypeInspector typeDescriptor;

		private readonly bool ignoreUnmatched;

		private readonly bool duplicateKeyChecking;

		private readonly ITypeConverter typeConverter;

		public ObjectNodeDeserializer(IObjectFactory objectFactory, ITypeInspector typeDescriptor, bool ignoreUnmatched, bool duplicateKeyChecking, ITypeConverter typeConverter)
		{
			this.objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
			this.typeDescriptor = typeDescriptor ?? throw new ArgumentNullException("typeDescriptor");
			this.ignoreUnmatched = ignoreUnmatched;
			this.duplicateKeyChecking = duplicateKeyChecking;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			value = objectFactory.Create(type);
			objectFactory.ExecuteOnDeserializing(value);
			HashSet<string> hashSet = new HashSet<string>(StringComparer.Ordinal);
			MappingEnd event2;
			while (!parser.TryConsume<MappingEnd>(out event2))
			{
				YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
				if (duplicateKeyChecking && !hashSet.Add(scalar.Value))
				{
					Mark start = scalar.Start;
					Mark end = scalar.End;
					throw new YamlException(ref start, ref end, "Encountered duplicate key " + scalar.Value);
				}
				try
				{
					IPropertyDescriptor property = typeDescriptor.GetProperty(type, null, scalar.Value, ignoreUnmatched);
					if (property == null)
					{
						parser.SkipThisAndNestedEvents();
						continue;
					}
					object obj = nestedObjectDeserializer(parser, property.Type);
					if (obj is IValuePromise valuePromise)
					{
						object valueRef = value;
						valuePromise.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
						{
							object value3 = typeConverter.ChangeType(v, property.Type);
							property.Write(valueRef, value3);
						};
					}
					else
					{
						object value2 = typeConverter.ChangeType(obj, property.Type);
						property.Write(value, value2);
					}
				}
				catch (SerializationException ex)
				{
					Mark start = scalar.Start;
					Mark end = scalar.End;
					throw new YamlException(ref start, ref end, ex.Message);
				}
				catch (YamlException)
				{
					throw;
				}
				catch (Exception innerException)
				{
					Mark start = scalar.Start;
					Mark end = scalar.End;
					throw new YamlException(ref start, ref end, "Exception during deserialization", innerException);
				}
			}
			objectFactory.ExecuteOnDeserialized(value);
			return true;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class ScalarNodeDeserializer : INodeDeserializer
	{
		private const string BooleanTruePattern = "^(true|y|yes|on)$";

		private const string BooleanFalsePattern = "^(false|n|no|off)$";

		private readonly bool attemptUnknownTypeDeserialization;

		private readonly ITypeConverter typeConverter;

		private readonly YamlFormatter formatter;

		public ScalarNodeDeserializer(bool attemptUnknownTypeDeserialization, ITypeConverter typeConverter, YamlFormatter formatter)
		{
			this.attemptUnknownTypeDeserialization = attemptUnknownTypeDeserialization;
			this.typeConverter = typeConverter ?? throw new ArgumentNullException("typeConverter");
			this.formatter = formatter;
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (!parser.TryConsume<YamlDotNet.Core.Events.Scalar>(out var @event))
			{
				value = null;
				return false;
			}
			Type type = Nullable.GetUnderlyingType(expectedType) ?? expectedType;
			if (type.IsEnum())
			{
				value = Enum.Parse(type, @event.Value, ignoreCase: true);
				return true;
			}
			TypeCode typeCode = type.GetTypeCode();
			switch (typeCode)
			{
			case TypeCode.Boolean:
				value = DeserializeBooleanHelper(@event.Value);
				break;
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
				value = DeserializeIntegerHelper(typeCode, @event.Value);
				break;
			case TypeCode.Single:
				value = float.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Double:
				value = double.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.Decimal:
				value = decimal.Parse(@event.Value, formatter.NumberFormat);
				break;
			case TypeCode.String:
				value = @event.Value;
				break;
			case TypeCode.Char:
				value = @event.Value[0];
				break;
			case TypeCode.DateTime:
				value = DateTime.Parse(@event.Value, CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind);
				break;
			default:
				if (expectedType == typeof(object))
				{
					if (!@event.IsKey && attemptUnknownTypeDeserialization)
					{
						value = AttemptUnknownTypeDeserialization(@event);
					}
					else
					{
						value = @event.Value;
					}
				}
				else
				{
					value = typeConverter.ChangeType(@event.Value, expectedType);
				}
				break;
			}
			return true;
		}

		private object DeserializeBooleanHelper(string value)
		{
			bool flag;
			if (Regex.IsMatch(value, "^(true|y|yes|on)$", RegexOptions.IgnoreCase))
			{
				flag = true;
			}
			else
			{
				if (!Regex.IsMatch(value, "^(false|n|no|off)$", RegexOptions.IgnoreCase))
				{
					throw new FormatException("The value \"" + value + "\" is not a valid YAML Boolean");
				}
				flag = false;
			}
			return flag;
		}

		private object DeserializeIntegerHelper(TypeCode typeCode, string value)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				int i = 0;
				bool flag = false;
				ulong num = 0uL;
				if (value[0] == '-')
				{
					i++;
					flag = true;
				}
				else if (value[0] == '+')
				{
					i++;
				}
				if (value[i] == '0')
				{
					int num2;
					if (i == value.Length - 1)
					{
						num2 = 10;
						num = 0uL;
					}
					else
					{
						i++;
						if (value[i] == 'b')
						{
							num2 = 2;
							i++;
						}
						else if (value[i] == 'x')
						{
							num2 = 16;
							i++;
						}
						else
						{
							num2 = 8;
						}
					}
					for (; i < value.Length; i++)
					{
						if (value[i] != '_')
						{
							builder.Append(value[i]);
						}
					}
					switch (num2)
					{
					case 2:
					case 8:
						num = Convert.ToUInt64(builder.ToString(), num2);
						break;
					case 16:
						num = ulong.Parse(builder.ToString(), NumberStyles.HexNumber, formatter.NumberFormat);
						break;
					}
				}
				else
				{
					string[] array = value.Substring(i).Split(new char[1] { ':' });
					num = 0uL;
					for (int j = 0; j < array.Length; j++)
					{
						num *= 60;
						num += ulong.Parse(array[j].Replace("_", ""));
					}
				}
				if (!flag)
				{
					return CastInteger(num, typeCode);
				}
				long number = ((num != 9223372036854775808uL) ? checked(-(long)num) : long.MinValue);
				return CastInteger(number, typeCode);
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private static object CastInteger(long number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => (ulong)number, 
				_ => number, 
			});
		}

		private static object CastInteger(ulong number, TypeCode typeCode)
		{
			return checked(typeCode switch
			{
				TypeCode.Byte => (byte)number, 
				TypeCode.Int16 => (short)number, 
				TypeCode.Int32 => (int)number, 
				TypeCode.Int64 => (long)number, 
				TypeCode.SByte => (sbyte)number, 
				TypeCode.UInt16 => (ushort)number, 
				TypeCode.UInt32 => (uint)number, 
				TypeCode.UInt64 => number, 
				_ => number, 
			});
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private object AttemptUnknownTypeDeserialization(YamlDotNet.Core.Events.Scalar value)
		{
			if (value.Style == ScalarStyle.SingleQuoted || value.Style == ScalarStyle.DoubleQuoted || value.Style == ScalarStyle.Folded)
			{
				return value.Value;
			}
			string v = value.Value;
			switch (v)
			{
			case "null":
			case "Null":
			case "NULL":
			case "~":
			case "":
				return null;
			case "true":
			case "True":
			case "TRUE":
				return true;
			case "False":
			case "FALSE":
			case "false":
				return false;
			default:
			{
				object value2;
				if (Regex.IsMatch(v, "0x[0-9a-fA-F]+"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 16), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 16), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 16), out value2))
					{
						return v;
					}
				}
				else if (Regex.IsMatch(v, "0o[0-9a-fA-F]+"))
				{
					if (!TryAndSwallow(() => Convert.ToByte(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt16(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt32(v, 8), out value2) && !TryAndSwallow(() => Convert.ToInt64(v, 8), out value2) && !TryAndSwallow(() => Convert.ToUInt64(v, 8), out value2))
					{
						return v;
					}
				}
				else
				{
					if (!Regex.IsMatch(v, "[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?"))
					{
						if (Regex.IsMatch(v, "^[-+]?(\\.inf|\\.Inf|\\.INF)$"))
						{
							if (v.StartsWith("-"))
							{
								return float.NegativeInfinity;
							}
							return float.PositiveInfinity;
						}
						if (Regex.IsMatch(v, "^(\\.nan|\\.NaN|\\.NAN)$"))
						{
							return float.NaN;
						}
						return v;
					}
					if (!TryAndSwallow(() => byte.Parse(v, formatter.NumberFormat), out value2) && !TryAndSwallow(() => short.Parse(v, formatter.NumberFormat), out value2) && !TryAndSwallow(() => int.Parse(v, formatter.NumberFormat), out value2) && !TryAndSwallow(() => long.Parse(v, formatter.NumberFormat), out value2) && !TryAndSwallow(() => ulong.Parse(v, formatter.NumberFormat), out value2) && !TryAndSwallow(() => float.Parse(v, formatter.NumberFormat), out value2) && !TryAndSwallow(() => double.Parse(v, formatter.NumberFormat), out value2))
					{
						return v;
					}
				}
				return value2;
			}
			}
		}

		private static bool TryAndSwallow(Func<object> attempt, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			try
			{
				value = attempt();
				return true;
			}
			catch
			{
				value = null;
				return false;
			}
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class StaticArrayNodeDeserializer : INodeDeserializer
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private sealed class ArrayList : IList, ICollection, IEnumerable
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 2 })]
			private object[] data;

			public bool IsFixedSize => false;

			public bool IsReadOnly => false;

			public object this[int index]
			{
				get
				{
					return data[index];
				}
				set
				{
					data[index] = value;
				}
			}

			public int Count { get; private set; }

			public bool IsSynchronized => false;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
			public object SyncRoot
			{
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
				get
				{
					return data;
				}
			}

			public ArrayList()
			{
				Clear();
			}

			public int Add(object value)
			{
				if (Count == data.Length)
				{
					Array.Resize(ref data, data.Length * 2);
				}
				data[Count] = value;
				return Count++;
			}

			public void Clear()
			{
				data = new object[10];
				Count = 0;
			}

			bool IList.Contains(object value)
			{
				throw new NotSupportedException();
			}

			int IList.IndexOf(object value)
			{
				throw new NotSupportedException();
			}

			void IList.Insert(int index, object value)
			{
				throw new NotSupportedException();
			}

			void IList.Remove(object value)
			{
				throw new NotSupportedException();
			}

			void IList.RemoveAt(int index)
			{
				throw new NotSupportedException();
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			public void CopyTo(Array array, int index)
			{
				Array.Copy(data, 0, array, index, Count);
			}

			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			public IEnumerator GetEnumerator()
			{
				int i = 0;
				while (i < Count)
				{
					yield return data[i];
					int num = i + 1;
					i = num;
				}
			}
		}

		private readonly StaticObjectFactory factory;

		public StaticArrayNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (!factory.IsArray(expectedType))
			{
				value = false;
				return false;
			}
			Type valueType = factory.GetValueType(expectedType);
			ArrayList arrayList = new ArrayList();
			StaticCollectionNodeDeserializer.DeserializeHelper(valueType, parser, nestedObjectDeserializer, arrayList, factory);
			Array array = factory.CreateArray(expectedType, arrayList.Count);
			arrayList.CopyTo(array, 0);
			value = array;
			return true;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class StaticCollectionNodeDeserializer : INodeDeserializer
	{
		private readonly StaticObjectFactory factory;

		public StaticCollectionNodeDeserializer(StaticObjectFactory factory)
		{
			this.factory = factory ?? throw new ArgumentNullException("factory");
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (!factory.IsList(expectedType))
			{
				value = null;
				return false;
			}
			DeserializeHelper(result: (IList)(value = factory.Create(expectedType) as IList), tItem: factory.GetValueType(expectedType), parser: parser, nestedObjectDeserializer: nestedObjectDeserializer, factory: factory);
			return true;
		}

		internal static void DeserializeHelper(Type tItem, IParser parser, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, IList result, IObjectFactory factory)
		{
			parser.Consume<SequenceStart>();
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				_ = parser.Current;
				object obj = nestedObjectDeserializer(parser, tItem);
				if (obj is IValuePromise valuePromise)
				{
					int index = result.Add(factory.CreatePrimitive(tItem));
					valuePromise.ValueAvailable += [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)] (object v) =>
					{
						result[index] = v;
					};
				}
				else
				{
					result.Add(obj);
				}
			}
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class StaticDictionaryNodeDeserializer : DictionaryDeserializer, INodeDeserializer
	{
		private readonly StaticObjectFactory _objectFactory;

		public StaticDictionaryNodeDeserializer(StaticObjectFactory objectFactory, bool duplicateKeyChecking)
			: base(duplicateKeyChecking)
		{
			_objectFactory = objectFactory ?? throw new ArgumentNullException("objectFactory");
		}

		public bool Deserialize(IParser reader, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (_objectFactory.IsDictionary(expectedType))
			{
				if (!(_objectFactory.Create(expectedType) is IDictionary dictionary))
				{
					value = null;
					return false;
				}
				Type keyType = _objectFactory.GetKeyType(expectedType);
				Type valueType = _objectFactory.GetValueType(expectedType);
				value = dictionary;
				base.Deserialize(keyType, valueType, reader, nestedObjectDeserializer, dictionary);
				return true;
			}
			value = null;
			return false;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class TypeConverterNodeDeserializer : INodeDeserializer
	{
		private readonly IEnumerable<IYamlTypeConverter> converters;

		public TypeConverterNodeDeserializer(IEnumerable<IYamlTypeConverter> converters)
		{
			this.converters = converters ?? throw new ArgumentNullException("converters");
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			IYamlTypeConverter yamlTypeConverter = converters.FirstOrDefault([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (IYamlTypeConverter c) => c.Accepts(expectedType));
			if (yamlTypeConverter == null)
			{
				value = null;
				return false;
			}
			value = yamlTypeConverter.ReadYaml(parser, expectedType);
			return true;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class YamlConvertibleNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlConvertibleNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (typeof(IYamlConvertible).IsAssignableFrom(expectedType))
			{
				IYamlConvertible yamlConvertible = (IYamlConvertible)objectFactory.Create(expectedType);
				yamlConvertible.Read(parser, expectedType, [return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] (Type type) => nestedObjectDeserializer(parser, type));
				value = yamlConvertible;
				return true;
			}
			value = null;
			return false;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class YamlSerializableNodeDeserializer : INodeDeserializer
	{
		private readonly IObjectFactory objectFactory;

		public YamlSerializableNodeDeserializer(IObjectFactory objectFactory)
		{
			this.objectFactory = objectFactory;
		}

		public bool Deserialize(IParser parser, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (typeof(IYamlSerializable).IsAssignableFrom(expectedType))
			{
				IYamlSerializable yamlSerializable = (IYamlSerializable)objectFactory.Create(expectedType);
				yamlSerializable.ReadYaml(parser);
				value = yamlSerializable;
				return true;
			}
			value = null;
			return false;
		}
	}
}
namespace YamlDotNet.Serialization.NamingConventions
{
	internal sealed class CamelCaseNamingConvention : INamingConvention
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static readonly INamingConvention Instance = new CamelCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public CamelCaseNamingConvention()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public string Apply(string value)
		{
			return value.ToCamelCase();
		}
	}
	internal sealed class HyphenatedNamingConvention : INamingConvention
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static readonly INamingConvention Instance = new HyphenatedNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public HyphenatedNamingConvention()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public string Apply(string value)
		{
			return value.FromCamelCase("-");
		}
	}
	internal sealed class LowerCaseNamingConvention : INamingConvention
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static readonly INamingConvention Instance = new LowerCaseNamingConvention();

		private LowerCaseNamingConvention()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public string Apply(string value)
		{
			return value.ToCamelCase().ToLower();
		}
	}
	internal sealed class NullNamingConvention : INamingConvention
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static readonly INamingConvention Instance = new NullNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public NullNamingConvention()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public string Apply(string value)
		{
			return value;
		}
	}
	internal sealed class PascalCaseNamingConvention : INamingConvention
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static readonly INamingConvention Instance = new PascalCaseNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public PascalCaseNamingConvention()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public string Apply(string value)
		{
			return value.ToPascalCase();
		}
	}
	internal sealed class UnderscoredNamingConvention : INamingConvention
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static readonly INamingConvention Instance = new UnderscoredNamingConvention();

		[Obsolete("Use the Instance static field instead of creating new instances")]
		public UnderscoredNamingConvention()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public string Apply(string value)
		{
			return value.FromCamelCase("_");
		}
	}
}
namespace YamlDotNet.Serialization.EventEmitters
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal abstract class ChainedEventEmitter : IEventEmitter
	{
		protected readonly IEventEmitter nextEmitter;

		protected ChainedEventEmitter(IEventEmitter nextEmitter)
		{
			this.nextEmitter = nextEmitter ?? throw new ArgumentNullException("nextEmitter");
		}

		public virtual void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}

		public virtual void Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			nextEmitter.Emit(eventInfo, emitter);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class JsonEventEmitter : ChainedEventEmitter
	{
		private readonly YamlFormatter formatter;

		public JsonEventEmitter(IEventEmitter nextEmitter, YamlFormatter formatter)
			: base(nextEmitter)
		{
			this.formatter = formatter;
		}

		public JsonEventEmitter(IEventEmitter nextEmitter)
			: this(nextEmitter, YamlFormatter.Default)
		{
		}

		public override void Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.NeedsExpansion = true;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.IsPlainImplicit = true;
			eventInfo.Style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.RenderedValue = "null";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum())
					{
						eventInfo.RenderedValue = value.ToString();
						eventInfo.Style = ScalarStyle.DoubleQuoted;
					}
					else
					{
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
				case TypeCode.Double:
				case TypeCode.Decimal:
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.RenderedValue = value.ToString();
					eventInfo.Style = ScalarStyle.DoubleQuoted;
					break;
				case TypeCode.DateTime:
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.RenderedValue = "null";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = MappingStyle.Flow;
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			eventInfo.Style = SequenceStyle.Flow;
			base.Emit(eventInfo, emitter);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class TypeAssigningEventEmitter : ChainedEventEmitter
	{
		private readonly bool requireTagWhenStaticAndActualTypesAreDifferent;

		private readonly IDictionary<Type, TagName> tagMappings;

		private readonly bool quoteNecessaryStrings;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private readonly Regex isSpecialStringValue_Regex;

		private static readonly string SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|[-+]?[0-9]+|0o[0-7]+|0x[0-9a-fA-F]+|[-+]?(\\.[0-9]+|[0-9]+(\\.[0-9]*)?)([eE][-+]?[0-9]+)?|[-+]?(\\.inf|\\.Inf|\\.INF)|\\.nan|\\.NaN|\\.NAN)$";

		private static readonly string CombinedYaml1_1SpecialStrings_Pattern = "^(null|Null|NULL|\\~|true|True|TRUE|false|False|FALSE|y|Y|yes|Yes|YES|n|N|no|No|NO|on|On|ON|off|Off|OFF|[-+]?0b[0-1_]+|[-+]?0o?[0-7_]+|[-+]?(0|[1-9][0-9_]*)|[-+]?0x[0-9a-fA-F_]+|[-+]?[1-9][0-9_]*(:[0-5]?[0-9])+|[-+]?([0-9][0-9_]*)?\\.[0-9_]*([eE][-+][0-9]+)?|[-+]?[0-9][0-9_]*(:[0-5]?[0-9])+\\.[0-9_]*|[-+]?\\.(inf|Inf|INF)|\\.(nan|NaN|NAN))$";

		private readonly ScalarStyle defaultScalarStyle;

		private readonly YamlFormatter formatter;

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle, YamlFormatter formatter)
			: base(nextEmitter)
		{
			this.defaultScalarStyle = defaultScalarStyle;
			this.formatter = formatter;
			this.tagMappings = tagMappings;
			this.quoteNecessaryStrings = quoteNecessaryStrings;
			isSpecialStringValue_Regex = new Regex(quoteYaml1_1Strings ? CombinedYaml1_1SpecialStrings_Pattern : SpecialStrings_Pattern, RegexOptions.Compiled);
		}

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings, ScalarStyle defaultScalarStyle)
			: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, defaultScalarStyle, YamlFormatter.Default)
		{
		}

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, ScalarStyle defaultScalarStyle)
			: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false, defaultScalarStyle, YamlFormatter.Default)
		{
		}

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings, bool quoteYaml1_1Strings)
			: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings, ScalarStyle.Any)
		{
		}

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings, bool quoteNecessaryStrings)
			: this(nextEmitter, requireTagWhenStaticAndActualTypesAreDifferent, tagMappings, quoteNecessaryStrings, quoteYaml1_1Strings: false)
		{
		}

		public TypeAssigningEventEmitter(IEventEmitter nextEmitter, bool requireTagWhenStaticAndActualTypesAreDifferent, IDictionary<Type, TagName> tagMappings)
			: base(nextEmitter)
		{
			this.requireTagWhenStaticAndActualTypesAreDifferent = requireTagWhenStaticAndActualTypesAreDifferent;
			this.tagMappings = tagMappings ?? throw new ArgumentNullException("tagMappings");
			formatter = YamlFormatter.Default;
		}

		public override void Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			ScalarStyle style = ScalarStyle.Plain;
			object value = eventInfo.Source.Value;
			if (value == null)
			{
				eventInfo.Tag = JsonSchema.Tags.Null;
				eventInfo.RenderedValue = "";
			}
			else
			{
				TypeCode typeCode = eventInfo.Source.Type.GetTypeCode();
				switch (typeCode)
				{
				case TypeCode.Boolean:
					eventInfo.Tag = JsonSchema.Tags.Bool;
					eventInfo.RenderedValue = formatter.FormatBoolean(value);
					break;
				case TypeCode.SByte:
				case TypeCode.Byte:
				case TypeCode.Int16:
				case TypeCode.UInt16:
				case TypeCode.Int32:
				case TypeCode.UInt32:
				case TypeCode.Int64:
				case TypeCode.UInt64:
					if (eventInfo.Source.Type.IsEnum)
					{
						eventInfo.Tag = FailsafeSchema.Tags.Str;
						eventInfo.RenderedValue = value.ToString();
						style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					}
					else
					{
						eventInfo.Tag = JsonSchema.Tags.Int;
						eventInfo.RenderedValue = formatter.FormatNumber(value);
					}
					break;
				case TypeCode.Single:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((float)value);
					break;
				case TypeCode.Double:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber((double)value);
					break;
				case TypeCode.Decimal:
					eventInfo.Tag = JsonSchema.Tags.Float;
					eventInfo.RenderedValue = formatter.FormatNumber(value);
					break;
				case TypeCode.Char:
				case TypeCode.String:
					eventInfo.Tag = FailsafeSchema.Tags.Str;
					eventInfo.RenderedValue = value.ToString();
					style = ((!quoteNecessaryStrings || !IsSpecialStringValue(eventInfo.RenderedValue)) ? defaultScalarStyle : ScalarStyle.DoubleQuoted);
					break;
				case TypeCode.DateTime:
					eventInfo.Tag = DefaultSchema.Tags.Timestamp;
					eventInfo.RenderedValue = formatter.FormatDateTime(value);
					break;
				case TypeCode.Empty:
					eventInfo.Tag = JsonSchema.Tags.Null;
					eventInfo.RenderedValue = "";
					break;
				default:
					if (eventInfo.Source.Type == typeof(TimeSpan))
					{
						eventInfo.RenderedValue = formatter.FormatTimeSpan(value);
						break;
					}
					throw new NotSupportedException($"TypeCode.{typeCode} is not supported.");
				}
			}
			eventInfo.IsPlainImplicit = true;
			if (eventInfo.Style == ScalarStyle.Any)
			{
				eventInfo.Style = style;
			}
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		public override void Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			AssignTypeIfNeeded(eventInfo);
			base.Emit(eventInfo, emitter);
		}

		private void AssignTypeIfNeeded(ObjectEventInfo eventInfo)
		{
			if (tagMappings.TryGetValue(eventInfo.Source.Type, out var value))
			{
				eventInfo.Tag = value;
			}
			else if (requireTagWhenStaticAndActualTypesAreDifferent && eventInfo.Source.Value != null && eventInfo.Source.Type != eventInfo.Source.StaticType)
			{
				throw new YamlException("Cannot serialize type '" + eventInfo.Source.Type.FullName + "' where a '" + eventInfo.Source.StaticType.FullName + "' was expected because no tag mapping has been registered for '" + eventInfo.Source.Type.FullName + "', which means that it won't be possible to deserialize the document.\nRegister a tag mapping using the SerializerBuilder.WithTagMapping method.\n\nE.g: builder.WithTagMapping(\"!" + eventInfo.Source.Type.Name + "\", typeof(" + eventInfo.Source.Type.FullName + "));");
			}
		}

		private bool IsSpecialStringValue(string value)
		{
			if (value.Trim() == string.Empty)
			{
				return true;
			}
			return isSpecialStringValue_Regex?.IsMatch(value) ?? false;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class WriterEventEmitter : IEventEmitter
	{
		void IEventEmitter.Emit(AliasEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(eventInfo.Alias));
		}

		void IEventEmitter.Emit(ScalarEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(eventInfo.Anchor, eventInfo.Tag, eventInfo.RenderedValue, eventInfo.Style, eventInfo.IsPlainImplicit, eventInfo.IsQuotedImplicit));
		}

		void IEventEmitter.Emit(MappingStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(MappingEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new MappingEnd());
		}

		void IEventEmitter.Emit(SequenceStartEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceStart(eventInfo.Anchor, eventInfo.Tag, eventInfo.IsImplicit, eventInfo.Style));
		}

		void IEventEmitter.Emit(SequenceEndEventInfo eventInfo, IEmitter emitter)
		{
			emitter.Emit(new SequenceEnd());
		}
	}
}
namespace YamlDotNet.Serialization.Converters
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class DateTimeConverter : IYamlTypeConverter
	{
		private readonly DateTimeKind kind;

		private readonly IFormatProvider provider;

		private readonly bool doubleQuotes;

		private readonly string[] formats;

		public DateTimeConverter(DateTimeKind kind = DateTimeKind.Utc, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] IFormatProvider provider = null, bool doubleQuotes = false, params string[] formats)
		{
			this.kind = ((kind == DateTimeKind.Unspecified) ? DateTimeKind.Utc : kind);
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.doubleQuotes = doubleQuotes;
			this.formats = formats.DefaultIfEmpty("G").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTime);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			return EnsureDateTimeKind(DateTime.ParseExact(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value, style: (kind == DateTimeKind.Local) ? DateTimeStyles.AssumeLocal : DateTimeStyles.AssumeUniversal, formats: formats, provider: provider), kind);
		}

		public void WriteYaml(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type type)
		{
			DateTime dateTime = (DateTime)value;
			string value2 = ((kind == DateTimeKind.Local) ? dateTime.ToLocalTime() : dateTime.ToUniversalTime()).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, doubleQuotes ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}

		private static DateTime EnsureDateTimeKind(DateTime dt, DateTimeKind kind)
		{
			if (dt.Kind == DateTimeKind.Local && kind == DateTimeKind.Utc)
			{
				return dt.ToUniversalTime();
			}
			if (dt.Kind == DateTimeKind.Utc && kind == DateTimeKind.Local)
			{
				return dt.ToLocalTime();
			}
			return dt;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class DateTimeOffsetConverter : IYamlTypeConverter
	{
		private readonly IFormatProvider provider;

		private readonly ScalarStyle style;

		private readonly DateTimeStyles dateStyle;

		private readonly string[] formats;

		public DateTimeOffsetConverter([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] IFormatProvider provider = null, ScalarStyle style = ScalarStyle.Any, DateTimeStyles dateStyle = DateTimeStyles.None, params string[] formats)
		{
			this.provider = provider ?? CultureInfo.InvariantCulture;
			this.style = style;
			this.dateStyle = dateStyle;
			this.formats = formats.DefaultIfEmpty("O").ToArray();
		}

		public bool Accepts(Type type)
		{
			return type == typeof(DateTimeOffset);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			return DateTimeOffset.ParseExact(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value, formats, provider, dateStyle);
		}

		public void WriteYaml(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type type)
		{
			string value2 = ((DateTimeOffset)value).ToString(formats.First(), provider);
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, value2, style, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class GuidConverter : IYamlTypeConverter
	{
		private readonly bool jsonCompatible;

		public GuidConverter(bool jsonCompatible)
		{
			this.jsonCompatible = jsonCompatible;
		}

		public bool Accepts(Type type)
		{
			return type == typeof(Guid);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			return new Guid(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value);
		}

		public void WriteYaml(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type type)
		{
			Guid guid = (Guid)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, guid.ToString("D"), jsonCompatible ? ScalarStyle.DoubleQuoted : ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class SystemTypeConverter : IYamlTypeConverter
	{
		public bool Accepts(Type type)
		{
			return typeof(Type).IsAssignableFrom(type);
		}

		public object ReadYaml(IParser parser, Type type)
		{
			return Type.GetType(parser.Consume<YamlDotNet.Core.Events.Scalar>().Value, throwOnError: true);
		}

		public void WriteYaml(IEmitter emitter, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value, Type type)
		{
			Type type2 = (Type)value;
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, type2.AssemblyQualifiedName, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: false));
		}
	}
}
namespace YamlDotNet.Serialization.Callbacks
{
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnDeserializingAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializedAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method)]
	internal sealed class OnSerializingAttribute : Attribute
	{
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface ITypeDiscriminatingNodeDeserializerOptions
	{
		void AddTypeDiscriminator(ITypeDiscriminator discriminator);

		void AddKeyValueTypeDiscriminator<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping);

		void AddUniqueKeyTypeDiscriminator<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(IDictionary<string, Type> uniqueKeyTypeMapping);
	}
	internal class ParserBuffer : IParser
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		private readonly LinkedList<ParsingEvent> buffer;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })]
		private LinkedListNode<ParsingEvent> current;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public ParsingEvent Current
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get
			{
				return current?.Value;
			}
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public ParserBuffer(IParser parserToBuffer, int maxDepth, int maxLength)
		{
			buffer = new LinkedList<ParsingEvent>();
			buffer.AddLast(parserToBuffer.Consume<MappingStart>());
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parserToBuffer.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
				buffer.AddLast(parsingEvent);
				if (maxDepth > -1 && num > maxDepth)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max depth");
				}
				if (maxLength > -1 && buffer.Count > maxLength)
				{
					throw new ArgumentOutOfRangeException("parserToBuffer", "Parser buffer exceeded max length");
				}
			}
			while (num >= 0);
			current = buffer.First;
		}

		public bool MoveNext()
		{
			current = current?.Next;
			return current != null;
		}

		public void Reset()
		{
			current = buffer.First;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class TypeDiscriminatingNodeDeserializer : INodeDeserializer
	{
		private readonly IList<INodeDeserializer> innerDeserializers;

		private readonly IList<ITypeDiscriminator> typeDiscriminators;

		private readonly int maxDepthToBuffer;

		private readonly int maxLengthToBuffer;

		public TypeDiscriminatingNodeDeserializer(IList<INodeDeserializer> innerDeserializers, IList<ITypeDiscriminator> typeDiscriminators, int maxDepthToBuffer, int maxLengthToBuffer)
		{
			this.innerDeserializers = innerDeserializers;
			this.typeDiscriminators = typeDiscriminators;
			this.maxDepthToBuffer = maxDepthToBuffer;
			this.maxLengthToBuffer = maxLengthToBuffer;
		}

		public bool Deserialize(IParser reader, Type expectedType, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 1, 1, 2 })] Func<IParser, Type, object> nestedObjectDeserializer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out object value)
		{
			if (!reader.Accept<MappingStart>(out var _))
			{
				value = null;
				return false;
			}
			IEnumerable<ITypeDiscriminator> enumerable = typeDiscriminators.Where([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (ITypeDiscriminator t) => t.BaseType.IsAssignableFrom(expectedType));
			if (!enumerable.Any())
			{
				value = null;
				return false;
			}
			Mark start = reader.Current.Start;
			Type expectedType2 = expectedType;
			ParserBuffer parserBuffer;
			try
			{
				parserBuffer = new ParserBuffer(reader, maxDepthToBuffer, maxLengthToBuffer);
			}
			catch (Exception innerException)
			{
				Mark end = reader.Current.End;
				throw new YamlException(ref start, ref end, "Failed to buffer yaml node", innerException);
			}
			try
			{
				foreach (ITypeDiscriminator item in enumerable)
				{
					parserBuffer.Reset();
					if (item.TryDiscriminate(parserBuffer, out var suggestedType))
					{
						expectedType2 = suggestedType;
						break;
					}
				}
			}
			catch (Exception innerException2)
			{
				Mark end = reader.Current.End;
				throw new YamlException(ref start, ref end, "Failed to discriminate type", innerException2);
			}
			parserBuffer.Reset();
			foreach (INodeDeserializer innerDeserializer in innerDeserializers)
			{
				if (innerDeserializer.Deserialize(parserBuffer, expectedType2, nestedObjectDeserializer, out value))
				{
					return true;
				}
			}
			value = null;
			return false;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class TypeDiscriminatingNodeDeserializerOptions : ITypeDiscriminatingNodeDeserializerOptions
	{
		internal readonly List<ITypeDiscriminator> discriminators = new List<ITypeDiscriminator>();

		public void AddTypeDiscriminator(ITypeDiscriminator discriminator)
		{
			discriminators.Add(discriminator);
		}

		public void AddKeyValueTypeDiscriminator<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(string discriminatorKey, IDictionary<string, Type> valueTypeMapping)
		{
			discriminators.Add(new KeyValueTypeDiscriminator(typeof(T), discriminatorKey, valueTypeMapping));
		}

		public void AddUniqueKeyTypeDiscriminator<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(IDictionary<string, Type> uniqueKeyTypeMapping)
		{
			discriminators.Add(new UniqueKeyTypeDiscriminator(typeof(T), uniqueKeyTypeMapping));
		}
	}
}
namespace YamlDotNet.Serialization.BufferedDeserialization.TypeDiscriminators
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface ITypeDiscriminator
	{
		Type BaseType { get; }

		bool TryDiscriminate(IParser buffer, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out Type suggestedType);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class KeyValueTypeDiscriminator : ITypeDiscriminator
	{
		private readonly string targetKey;

		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public KeyValueTypeDiscriminator(Type baseType, string targetKey, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.targetKey = targetKey;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out Type suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => targetKey == scalar.Value, out var _, out var value) && value is YamlDotNet.Core.Events.Scalar scalar2 && typeMapping.TryGetValue(scalar2.Value, out var value2))
			{
				suggestedType = value2;
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class UniqueKeyTypeDiscriminator : ITypeDiscriminator
	{
		private readonly IDictionary<string, Type> typeMapping;

		public Type BaseType { get; private set; }

		public UniqueKeyTypeDiscriminator(Type baseType, IDictionary<string, Type> typeMapping)
		{
			foreach (KeyValuePair<string, Type> item in typeMapping)
			{
				if (!baseType.IsAssignableFrom(item.Value))
				{
					throw new ArgumentOutOfRangeException("typeMapping", $"{item.Value} is not a assignable to {baseType}");
				}
			}
			BaseType = baseType;
			this.typeMapping = typeMapping;
		}

		public bool TryDiscriminate(IParser parser, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out Type suggestedType)
		{
			if (parser.TryFindMappingEntry((YamlDotNet.Core.Events.Scalar scalar) => typeMapping.ContainsKey(scalar.Value), out var key, out var _))
			{
				suggestedType = typeMapping[key.Value];
				return true;
			}
			suggestedType = null;
			return false;
		}
	}
}
namespace YamlDotNet.RepresentationModel
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class DocumentLoadingState
	{
		private readonly IDictionary<AnchorName, YamlNode> anchors = new Dictionary<AnchorName, YamlNode>();

		private readonly IList<YamlNode> nodesWithUnresolvedAliases = new List<YamlNode>();

		public void AddAnchor(YamlNode node)
		{
			if (node.Anchor.IsEmpty)
			{
				throw new ArgumentException("The specified node does not have an anchor");
			}
			if (anchors.ContainsKey(node.Anchor))
			{
				anchors[node.Anchor] = node;
			}
			else
			{
				anchors.Add(node.Anchor, node);
			}
		}

		public YamlNode GetNode(AnchorName anchor, Mark start, Mark end)
		{
			if (anchors.TryGetValue(anchor, out var value))
			{
				return value;
			}
			throw new AnchorNotFoundException(ref start, ref end, $"The anchor '{anchor}' does not exists");
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public bool TryGetNode(AnchorName anchor, [NotNullWhen(true)] out YamlNode node)
		{
			return anchors.TryGetValue(anchor, out node);
		}

		public void AddNodeWithUnresolvedAliases(YamlNode node)
		{
			nodesWithUnresolvedAliases.Add(node);
		}

		public void ResolveAliases()
		{
			foreach (YamlNode nodesWithUnresolvedAlias in nodesWithUnresolvedAliases)
			{
				nodesWithUnresolvedAlias.ResolveAliases(this);
			}
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class EmitterState
	{
		public HashSet<AnchorName> EmittedAnchors { get; } = new HashSet<AnchorName>();

	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IYamlVisitor
	{
		void Visit(YamlStream stream);

		void Visit(YamlDocument document);

		void Visit(YamlScalarNode scalar);

		void Visit(YamlSequenceNode sequence);

		void Visit(YamlMappingNode mapping);
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class LibYamlEventStream
	{
		private readonly IParser parser;

		public LibYamlEventStream(IParser iParser)
		{
			parser = iParser ?? throw new ArgumentNullException("iParser");
		}

		public void WriteTo(TextWriter textWriter)
		{
			while (parser.MoveNext())
			{
				ParsingEvent current = parser.Current;
				if (!(current is YamlDotNet.Core.Events.AnchorAlias anchorAlias))
				{
					if (!(current is YamlDotNet.Core.Events.DocumentEnd documentEnd))
					{
						if (!(current is YamlDotNet.Core.Events.DocumentStart documentStart))
						{
							if (!(current is MappingEnd))
							{
								if (!(current is MappingStart nodeEvent))
								{
									if (!(current is YamlDotNet.Core.Events.Scalar scalar))
									{
										if (!(current is SequenceEnd))
										{
											if (!(current is SequenceStart nodeEvent2))
											{
												if (!(current is YamlDotNet.Core.Events.StreamEnd))
												{
													if (current is YamlDotNet.Core.Events.StreamStart)
													{
														textWriter.Write("+STR");
													}
												}
												else
												{
													textWriter.Write("-STR");
												}
											}
											else
											{
												textWriter.Write("+SEQ");
												WriteAnchorAndTag(textWriter, nodeEvent2);
											}
										}
										else
										{
											textWriter.Write("-SEQ");
										}
									}
									else
									{
										textWriter.Write("=VAL");
										WriteAnchorAndTag(textWriter, scalar);
										switch (scalar.Style)
										{
										case ScalarStyle.DoubleQuoted:
											textWriter.Write(" \"");
											break;
										case ScalarStyle.SingleQuoted:
											textWriter.Write(" '");
											break;
										case ScalarStyle.Folded:
											textWriter.Write(" >");
											break;
										case ScalarStyle.Literal:
											textWriter.Write(" |");
											break;
										default:
											textWriter.Write(" :");
											break;
										}
										string value = scalar.Value;
										foreach (char c in value)
										{
											switch (c)
											{
											case '\b':
												textWriter.Write("\\b");
												break;
											case '\t':
												textWriter.Write("\\t");
												break;
											case '\n':
												textWriter.Write("\\n");
												break;
											case '\r':
												textWriter.Write("\\r");
												break;
											case '\\':
												textWriter.Write("\\\\");
												break;
											default:
												textWriter.Write(c);
												break;
											}
										}
									}
								}
								else
								{
									textWriter.Write("+MAP");
									WriteAnchorAndTag(textWriter, nodeEvent);
								}
							}
							else
							{
								textWriter.Write("-MAP");
							}
						}
						else
						{
							textWriter.Write("+DOC");
							if (!documentStart.IsImplicit)
							{
								textWriter.Write(" ---");
							}
						}
					}
					else
					{
						textWriter.Write("-DOC");
						if (!documentEnd.IsImplicit)
						{
							textWriter.Write(" ...");
						}
					}
				}
				else
				{
					textWriter.Write("=ALI *");
					textWriter.Write(anchorAlias.Value);
				}
				textWriter.WriteLine();
			}
		}

		private void WriteAnchorAndTag(TextWriter textWriter, NodeEvent nodeEvent)
		{
			if (!nodeEvent.Anchor.IsEmpty)
			{
				textWriter.Write(" &");
				textWriter.Write(nodeEvent.Anchor);
			}
			if (!nodeEvent.Tag.IsEmpty)
			{
				textWriter.Write(" <");
				textWriter.Write(nodeEvent.Tag.Value);
				textWriter.Write(">");
			}
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class YamlAliasNode : YamlNode
	{
		public override YamlNodeType NodeType => YamlNodeType.Alias;

		internal YamlAliasNode(AnchorName anchor)
		{
			base.Anchor = anchor;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on an alias node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be saved.");
		}

		public override void Accept(IYamlVisitor visitor)
		{
			throw new NotSupportedException("A YamlAliasNode is an implementation detail and should never be visited.");
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is YamlAliasNode yamlAliasNode && Equals(yamlAliasNode))
			{
				return object.Equals(base.Anchor, yamlAliasNode.Anchor);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return base.GetHashCode();
		}

		internal override string ToString(RecursionLevel level)
		{
			return "*" + base.Anchor.ToString();
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class YamlDocument
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class AnchorAssigningVisitor : YamlVisitorBase
		{
			private readonly HashSet<AnchorName> existingAnchors = new HashSet<AnchorName>();

			private readonly Dictionary<YamlNode, bool> visitedNodes = new Dictionary<YamlNode, bool>();

			public void AssignAnchors(YamlDocument document)
			{
				existingAnchors.Clear();
				visitedNodes.Clear();
				document.Accept(this);
				Random random = new Random();
				foreach (KeyValuePair<YamlNode, bool> visitedNode in visitedNodes)
				{
					if (!visitedNode.Value)
					{
						continue;
					}
					AnchorName anchorName;
					if (!visitedNode.Key.Anchor.IsEmpty && !existingAnchors.Contains(visitedNode.Key.Anchor))
					{
						anchorName = visitedNode.Key.Anchor;
					}
					else
					{
						do
						{
							anchorName = new AnchorName(random.Next().ToString(CultureInfo.InvariantCulture));
						}
						while (existingAnchors.Contains(anchorName));
					}
					existingAnchors.Add(anchorName);
					visitedNode.Key.Anchor = anchorName;
				}
			}

			private bool VisitNodeAndFindDuplicates(YamlNode node)
			{
				if (visitedNodes.TryGetValue(node, out var value))
				{
					if (!value)
					{
						visitedNodes[node] = true;
					}
					return !value;
				}
				visitedNodes.Add(node, value: false);
				return false;
			}

			public override void Visit(YamlScalarNode scalar)
			{
				VisitNodeAndFindDuplicates(scalar);
			}

			public override void Visit(YamlMappingNode mapping)
			{
				if (!VisitNodeAndFindDuplicates(mapping))
				{
					base.Visit(mapping);
				}
			}

			public override void Visit(YamlSequenceNode sequence)
			{
				if (!VisitNodeAndFindDuplicates(sequence))
				{
					base.Visit(sequence);
				}
			}
		}

		public YamlNode RootNode { get; private set; }

		public IEnumerable<YamlNode> AllNodes => RootNode.AllNodes;

		public YamlDocument(YamlNode rootNode)
		{
			RootNode = rootNode;
		}

		public YamlDocument(string rootNode)
		{
			RootNode = new YamlScalarNode(rootNode);
		}

		internal YamlDocument(IParser parser)
		{
			DocumentLoadingState documentLoadingState = new DocumentLoadingState();
			parser.Consume<YamlDotNet.Core.Events.DocumentStart>();
			YamlDotNet.Core.Events.DocumentEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.DocumentEnd>(out @event))
			{
				RootNode = YamlNode.ParseNode(parser, documentLoadingState);
				if (RootNode is YamlAliasNode)
				{
					throw new YamlException("A document cannot contain only an alias");
				}
			}
			documentLoadingState.ResolveAliases();
			if (RootNode == null)
			{
				throw new ArgumentException("Atempted to parse an empty document");
			}
		}

		private void AssignAnchors()
		{
			new AnchorAssigningVisitor().AssignAnchors(this);
		}

		internal void Save(IEmitter emitter, bool assignAnchors = true)
		{
			if (assignAnchors)
			{
				AssignAnchors();
			}
			emitter.Emit(new YamlDotNet.Core.Events.DocumentStart());
			RootNode.Save(emitter, new EmitterState());
			emitter.Emit(new YamlDotNet.Core.Events.DocumentEnd(isImplicit: false));
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class YamlMappingNode : YamlNode, IEnumerable<KeyValuePair<YamlNode, YamlNode>>, IEnumerable, IYamlConvertible
	{
		private readonly OrderedDictionary<YamlNode, YamlNode> children = new OrderedDictionary<YamlNode, YamlNode>();

		public IOrderedDictionary<YamlNode, YamlNode> Children => children;

		public MappingStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Mapping;

		internal YamlMappingNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			MappingStart mappingStart = parser.Consume<MappingStart>();
			Load(mappingStart, state);
			Style = mappingStart.Style;
			bool flag = false;
			MappingEnd @event;
			while (!parser.TryConsume<MappingEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				YamlNode yamlNode2 = YamlNode.ParseNode(parser, state);
				try
				{
					children.Add(yamlNode, yamlNode2);
				}
				catch (ArgumentException innerException)
				{
					Mark start = yamlNode.Start;
					Mark end = yamlNode.End;
					throw new YamlException(ref start, ref end, "Duplicate key", innerException);
				}
				flag = flag || yamlNode is YamlAliasNode || yamlNode2 is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlMappingNode()
		{
		}

		public YamlMappingNode([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })] params KeyValuePair<YamlNode, YamlNode>[] children)
			: this((IEnumerable<KeyValuePair<YamlNode, YamlNode>>)children)
		{
		}

		public YamlMappingNode([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })] IEnumerable<KeyValuePair<YamlNode, YamlNode>> children)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				this.children.Add(child);
			}
		}

		public YamlMappingNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlMappingNode(IEnumerable<YamlNode> children)
		{
			using IEnumerator<YamlNode> enumerator = children.GetEnumerator();
			while (enumerator.MoveNext())
			{
				YamlNode current = enumerator.Current;
				if (!enumerator.MoveNext())
				{
					throw new ArgumentException("When constructing a mapping node with a sequence, the number of elements of the sequence must be even.");
				}
				Add(current, enumerator.Current);
			}
		}

		public void Add(YamlNode key, YamlNode value)
		{
			children.Add(key, value);
		}

		public void Add(string key, YamlNode value)
		{
			children.Add(new YamlScalarNode(key), value);
		}

		public void Add(YamlNode key, string value)
		{
			children.Add(key, new YamlScalarNode(value));
		}

		public void Add(string key, string value)
		{
			children.Add(new YamlScalarNode(key), new YamlScalarNode(value));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			Dictionary<YamlNode, YamlNode> dictionary = null;
			Dictionary<YamlNode, YamlNode> dictionary2 = null;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (child.Key is YamlAliasNode)
				{
					if (dictionary == null)
					{
						dictionary = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary.Add(child.Key, state.GetNode(child.Key.Anchor, child.Key.Start, child.Key.End));
				}
				if (child.Value is YamlAliasNode)
				{
					if (dictionary2 == null)
					{
						dictionary2 = new Dictionary<YamlNode, YamlNode>();
					}
					dictionary2.Add(child.Key, state.GetNode(child.Value.Anchor, child.Value.Start, child.Value.End));
				}
			}
			if (dictionary2 != null)
			{
				foreach (KeyValuePair<YamlNode, YamlNode> item in dictionary2)
				{
					children[item.Key] = item.Value;
				}
			}
			if (dictionary == null)
			{
				return;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> item2 in dictionary)
			{
				YamlNode value = children[item2.Key];
				children.Remove(item2.Key);
				children.Add(item2.Value, value);
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new MappingStart(base.Anchor, base.Tag, isImplicit: true, Style));
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				child.Key.Save(emitter, state);
				child.Value.Save(emitter, state);
			}
			emitter.Emit(new MappingEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (!(obj is YamlMappingNode yamlMappingNode) || !object.Equals(base.Tag, yamlMappingNode.Tag) || children.Count != yamlMappingNode.children.Count)
			{
				return false;
			}
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				if (!yamlMappingNode.children.TryGetValue(child.Key, out var value) || !object.Equals(child.Value, value))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int num = base.GetHashCode();
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Key);
				num = YamlDotNet.Core.HashCode.CombineHashCodes(num, child.Value);
			}
			return num;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (KeyValuePair<YamlNode, YamlNode> child in children)
			{
				foreach (YamlNode item in child.Key.SafeAllNodes(level))
				{
					yield return item;
				}
				foreach (YamlNode item2 in child.Value.SafeAllNodes(level))
				{
					yield return item2;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("{ ");
				foreach (KeyValuePair<YamlNode, YamlNode> child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append("{ ").Append(child.Key.ToString(level)).Append(", ")
						.Append(child.Value.ToString(level))
						.Append(" }");
				}
				builder.Append(" }");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })]
		public IEnumerator<KeyValuePair<YamlNode, YamlNode>> GetEnumerator()
		{
			return children.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}

		public static YamlMappingNode FromObject(object mapping)
		{
			if (mapping == null)
			{
				throw new ArgumentNullException("mapping");
			}
			YamlMappingNode yamlMappingNode = new YamlMappingNode();
			foreach (PropertyInfo publicProperty in mapping.GetType().GetPublicProperties())
			{
				if (publicProperty.CanRead && publicProperty.GetGetMethod(nonPublic: false).GetParameters().Length == 0)
				{
					object value = publicProperty.GetValue(mapping, null);
					YamlNode yamlNode = value as YamlNode;
					if (yamlNode == null)
					{
						yamlNode = Convert.ToString(value) ?? string.Empty;
					}
					yamlMappingNode.Add(publicProperty.Name, yamlNode);
				}
			}
			return yamlMappingNode;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal abstract class YamlNode
	{
		private const int MaximumRecursionLevel = 1000;

		internal const string MaximumRecursionLevelReachedToStringValue = "WARNING! INFINITE RECURSION!";

		public AnchorName Anchor { get; set; }

		public TagName Tag { get; set; }

		public Mark Start { get; private set; } = Mark.Empty;


		public Mark End { get; private set; } = Mark.Empty;


		public IEnumerable<YamlNode> AllNodes
		{
			get
			{
				RecursionLevel level = new RecursionLevel(1000);
				return SafeAllNodes(level);
			}
		}

		public abstract YamlNodeType NodeType { get; }

		public YamlNode this[int index]
		{
			get
			{
				if (!(this is YamlSequenceNode yamlSequenceNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {index}. Only Sequences can be indexed by number.");
				}
				return yamlSequenceNode.Children[index];
			}
		}

		public YamlNode this[YamlNode key]
		{
			get
			{
				if (!(this is YamlMappingNode yamlMappingNode))
				{
					throw new ArgumentException($"Accessed '{NodeType}' with an invalid index: {key}. Only Mappings can be indexed by key.");
				}
				return yamlMappingNode.Children[key];
			}
		}

		internal void Load(NodeEvent yamlEvent, DocumentLoadingState state)
		{
			Tag = yamlEvent.Tag;
			if (!yamlEvent.Anchor.IsEmpty)
			{
				Anchor = yamlEvent.Anchor;
				state.AddAnchor(this);
			}
			Start = yamlEvent.Start;
			End = yamlEvent.End;
		}

		internal static YamlNode ParseNode(IParser parser, DocumentLoadingState state)
		{
			if (parser.Accept<YamlDotNet.Core.Events.Scalar>(out var _))
			{
				return new YamlScalarNode(parser, state);
			}
			if (parser.Accept<SequenceStart>(out var _))
			{
				return new YamlSequenceNode(parser, state);
			}
			if (parser.Accept<MappingStart>(out var _))
			{
				return new YamlMappingNode(parser, state);
			}
			if (parser.TryConsume<YamlDotNet.Core.Events.AnchorAlias>(out var event4))
			{
				if (!state.TryGetNode(event4.Value, out var node))
				{
					return new YamlAliasNode(event4.Value);
				}
				return node;
			}
			throw new ArgumentException("The current event is of an unsupported type.", "parser");
		}

		internal abstract void ResolveAliases(DocumentLoadingState state);

		internal void Save(IEmitter emitter, EmitterState state)
		{
			if (!Anchor.IsEmpty && !state.EmittedAnchors.Add(Anchor))
			{
				emitter.Emit(new YamlDotNet.Core.Events.AnchorAlias(Anchor));
			}
			else
			{
				Emit(emitter, state);
			}
		}

		internal abstract void Emit(IEmitter emitter, EmitterState state);

		public abstract void Accept(IYamlVisitor visitor);

		public override string ToString()
		{
			RecursionLevel recursionLevel = new RecursionLevel(1000);
			return ToString(recursionLevel);
		}

		internal abstract string ToString(RecursionLevel level);

		internal abstract IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level);

		public static implicit operator YamlNode(string value)
		{
			return new YamlScalarNode(value);
		}

		public static implicit operator YamlNode(string[] sequence)
		{
			return new YamlSequenceNode(((IEnumerable<string>)sequence).Select((Func<string, YamlNode>)([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (string i) => i)));
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static explicit operator string(YamlNode node)
		{
			if (!(node is YamlScalarNode yamlScalarNode))
			{
				throw new ArgumentException($"Attempted to convert a '{node.NodeType}' to string. This conversion is valid only for Scalars.");
			}
			return yamlScalarNode.Value;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class YamlNodeIdentityEqualityComparer : IEqualityComparer<YamlNode>
	{
		public bool Equals([AllowNull] YamlNode x, [AllowNull] YamlNode y)
		{
			return x == y;
		}

		public int GetHashCode(YamlNode obj)
		{
			return obj.GetHashCode();
		}
	}
	internal enum YamlNodeType
	{
		Alias,
		Mapping,
		Scalar,
		Sequence
	}
	[DebuggerDisplay("{Value}")]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class YamlScalarNode : YamlNode, IYamlConvertible
	{
		private bool _forceImplicitPlain;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private string _value;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public string Value
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get
			{
				return _value;
			}
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			set
			{
				if (value == null)
				{
					_forceImplicitPlain = true;
				}
				else
				{
					_forceImplicitPlain = false;
				}
				_value = value;
			}
		}

		public ScalarStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Scalar;

		internal YamlScalarNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			YamlDotNet.Core.Events.Scalar scalar = parser.Consume<YamlDotNet.Core.Events.Scalar>();
			Load(scalar, state);
			if (scalar.Style == ScalarStyle.Plain && base.Tag.IsEmpty && (scalar.Value == string.Empty || scalar.Value.Equals("null", StringComparison.InvariantCulture) || scalar.Value.Equals("Null", StringComparison.InvariantCulture) || scalar.Value.Equals("NULL", StringComparison.InvariantCulture) || scalar.Value == "~"))
			{
				_forceImplicitPlain = true;
			}
			_value = scalar.Value;
			Style = scalar.Style;
		}

		public YamlScalarNode()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public YamlScalarNode(string value)
		{
			Value = value;
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			throw new NotSupportedException("Resolving an alias on a scalar node does not make sense");
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			TagName tag = base.Tag;
			bool isPlainImplicit = tag.IsEmpty;
			if (_forceImplicitPlain && Style == ScalarStyle.Plain && (Value == null || Value == ""))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			else if (tag.IsEmpty && Value == null && (Style == ScalarStyle.Plain || Style == ScalarStyle.Any))
			{
				tag = JsonSchema.Tags.Null;
				isPlainImplicit = true;
			}
			emitter.Emit(new YamlDotNet.Core.Events.Scalar(base.Anchor, tag, Value ?? string.Empty, Style, isPlainImplicit, isQuotedImplicit: false));
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is YamlScalarNode yamlScalarNode && object.Equals(base.Tag, yamlScalarNode.Tag))
			{
				return object.Equals(Value, yamlScalarNode.Value);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return YamlDotNet.Core.HashCode.CombineHashCodes(base.Tag.GetHashCode(), Value);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static explicit operator string(YamlScalarNode value)
		{
			return value.Value;
		}

		internal override string ToString(RecursionLevel level)
		{
			return Value ?? string.Empty;
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			yield return this;
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[DebuggerDisplay("Count = {children.Count}")]
	internal sealed class YamlSequenceNode : YamlNode, IEnumerable<YamlNode>, IEnumerable, IYamlConvertible
	{
		private readonly IList<YamlNode> children = new List<YamlNode>();

		public IList<YamlNode> Children => children;

		public SequenceStyle Style { get; set; }

		public override YamlNodeType NodeType => YamlNodeType.Sequence;

		internal YamlSequenceNode(IParser parser, DocumentLoadingState state)
		{
			Load(parser, state);
		}

		private void Load(IParser parser, DocumentLoadingState state)
		{
			SequenceStart sequenceStart = parser.Consume<SequenceStart>();
			Load(sequenceStart, state);
			Style = sequenceStart.Style;
			bool flag = false;
			SequenceEnd @event;
			while (!parser.TryConsume<SequenceEnd>(out @event))
			{
				YamlNode yamlNode = YamlNode.ParseNode(parser, state);
				children.Add(yamlNode);
				flag = flag || yamlNode is YamlAliasNode;
			}
			if (flag)
			{
				state.AddNodeWithUnresolvedAliases(this);
			}
		}

		public YamlSequenceNode()
		{
		}

		public YamlSequenceNode(params YamlNode[] children)
			: this((IEnumerable<YamlNode>)children)
		{
		}

		public YamlSequenceNode(IEnumerable<YamlNode> children)
		{
			foreach (YamlNode child in children)
			{
				this.children.Add(child);
			}
		}

		public void Add(YamlNode child)
		{
			children.Add(child);
		}

		public void Add(string child)
		{
			children.Add(new YamlScalarNode(child));
		}

		internal override void ResolveAliases(DocumentLoadingState state)
		{
			for (int i = 0; i < children.Count; i++)
			{
				if (children[i] is YamlAliasNode)
				{
					children[i] = state.GetNode(children[i].Anchor, children[i].Start, children[i].End);
				}
			}
		}

		internal override void Emit(IEmitter emitter, EmitterState state)
		{
			emitter.Emit(new SequenceStart(base.Anchor, base.Tag, base.Tag.IsEmpty, Style));
			foreach (YamlNode child in children)
			{
				child.Save(emitter, state);
			}
			emitter.Emit(new SequenceEnd());
		}

		public override void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (!(obj is YamlSequenceNode yamlSequenceNode) || !object.Equals(base.Tag, yamlSequenceNode.Tag) || children.Count != yamlSequenceNode.children.Count)
			{
				return false;
			}
			for (int i = 0; i < children.Count; i++)
			{
				if (!object.Equals(children[i], yamlSequenceNode.children[i]))
				{
					return false;
				}
			}
			return true;
		}

		public override int GetHashCode()
		{
			int h = 0;
			foreach (YamlNode child in children)
			{
				h = YamlDotNet.Core.HashCode.CombineHashCodes(h, child);
			}
			return YamlDotNet.Core.HashCode.CombineHashCodes(h, base.Tag);
		}

		internal override IEnumerable<YamlNode> SafeAllNodes(RecursionLevel level)
		{
			level.Increment();
			yield return this;
			foreach (YamlNode child in children)
			{
				foreach (YamlNode item in child.SafeAllNodes(level))
				{
					yield return item;
				}
			}
			level.Decrement();
		}

		internal override string ToString(RecursionLevel level)
		{
			if (!level.TryIncrement())
			{
				return "WARNING! INFINITE RECURSION!";
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append("[ ");
				foreach (YamlNode child in children)
				{
					if (builder.Length > 2)
					{
						builder.Append(", ");
					}
					builder.Append(child.ToString(level));
				}
				builder.Append(" ]");
				level.Decrement();
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		public IEnumerator<YamlNode> GetEnumerator()
		{
			return Children.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void IYamlConvertible.Read(IParser parser, Type expectedType, ObjectDeserializer nestedObjectDeserializer)
		{
			Load(parser, new DocumentLoadingState());
		}

		void IYamlConvertible.Write(IEmitter emitter, ObjectSerializer nestedObjectSerializer)
		{
			Emit(emitter, new EmitterState());
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class YamlStream : IEnumerable<YamlDocument>, IEnumerable
	{
		private readonly IList<YamlDocument> documents = new List<YamlDocument>();

		public IList<YamlDocument> Documents => documents;

		public YamlStream()
		{
		}

		public YamlStream(params YamlDocument[] documents)
			: this((IEnumerable<YamlDocument>)documents)
		{
		}

		public YamlStream(IEnumerable<YamlDocument> documents)
		{
			foreach (YamlDocument document in documents)
			{
				this.documents.Add(document);
			}
		}

		public void Add(YamlDocument document)
		{
			documents.Add(document);
		}

		public void Load(TextReader input)
		{
			Load(new Parser(input));
		}

		public void Load(IParser parser)
		{
			documents.Clear();
			parser.Consume<YamlDotNet.Core.Events.StreamStart>();
			YamlDotNet.Core.Events.StreamEnd @event;
			while (!parser.TryConsume<YamlDotNet.Core.Events.StreamEnd>(out @event))
			{
				YamlDocument item = new YamlDocument(parser);
				documents.Add(item);
			}
		}

		public void Save(TextWriter output)
		{
			Save(output, assignAnchors: true);
		}

		public void Save(TextWriter output, bool assignAnchors)
		{
			Save(new Emitter(output), assignAnchors);
		}

		public void Save(IEmitter emitter, bool assignAnchors)
		{
			emitter.Emit(new YamlDotNet.Core.Events.StreamStart());
			foreach (YamlDocument document in documents)
			{
				document.Save(emitter, assignAnchors);
			}
			emitter.Emit(new YamlDotNet.Core.Events.StreamEnd());
		}

		public void Accept(IYamlVisitor visitor)
		{
			visitor.Visit(this);
		}

		public IEnumerator<YamlDocument> GetEnumerator()
		{
			return documents.GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[Obsolete("Use YamlVisitorBase")]
	internal abstract class YamlVisitor : IYamlVisitor
	{
		protected virtual void Visit(YamlStream stream)
		{
		}

		protected virtual void Visited(YamlStream stream)
		{
		}

		protected virtual void Visit(YamlDocument document)
		{
		}

		protected virtual void Visited(YamlDocument document)
		{
		}

		protected virtual void Visit(YamlScalarNode scalar)
		{
		}

		protected virtual void Visited(YamlScalarNode scalar)
		{
		}

		protected virtual void Visit(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visited(YamlSequenceNode sequence)
		{
		}

		protected virtual void Visit(YamlMappingNode mapping)
		{
		}

		protected virtual void Visited(YamlMappingNode mapping)
		{
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				child.Key.Accept(this);
				child.Value.Accept(this);
			}
		}

		void IYamlVisitor.Visit(YamlStream stream)
		{
			Visit(stream);
			VisitChildren(stream);
			Visited(stream);
		}

		void IYamlVisitor.Visit(YamlDocument document)
		{
			Visit(document);
			VisitChildren(document);
			Visited(document);
		}

		void IYamlVisitor.Visit(YamlScalarNode scalar)
		{
			Visit(scalar);
			Visited(scalar);
		}

		void IYamlVisitor.Visit(YamlSequenceNode sequence)
		{
			Visit(sequence);
			VisitChildren(sequence);
			Visited(sequence);
		}

		void IYamlVisitor.Visit(YamlMappingNode mapping)
		{
			Visit(mapping);
			VisitChildren(mapping);
			Visited(mapping);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal abstract class YamlVisitorBase : IYamlVisitor
	{
		public virtual void Visit(YamlStream stream)
		{
			VisitChildren(stream);
		}

		public virtual void Visit(YamlDocument document)
		{
			VisitChildren(document);
		}

		public virtual void Visit(YamlScalarNode scalar)
		{
		}

		public virtual void Visit(YamlSequenceNode sequence)
		{
			VisitChildren(sequence);
		}

		public virtual void Visit(YamlMappingNode mapping)
		{
			VisitChildren(mapping);
		}

		protected virtual void VisitPair(YamlNode key, YamlNode value)
		{
			key.Accept(this);
			value.Accept(this);
		}

		protected virtual void VisitChildren(YamlStream stream)
		{
			foreach (YamlDocument document in stream.Documents)
			{
				document.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlDocument document)
		{
			if (document.RootNode != null)
			{
				document.RootNode.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlSequenceNode sequence)
		{
			foreach (YamlNode child in sequence.Children)
			{
				child.Accept(this);
			}
		}

		protected virtual void VisitChildren(YamlMappingNode mapping)
		{
			foreach (KeyValuePair<YamlNode, YamlNode> child in mapping.Children)
			{
				VisitPair(child.Key, child.Value);
			}
		}
	}
}
namespace YamlDotNet.Helpers
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[DebuggerStepThrough]
	internal sealed class ConcurrentObjectPool<T> where T : class
	{
		[DebuggerDisplay("{value,nq}")]
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		private struct Element
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			internal T value;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		internal delegate T Factory();

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private T firstItem;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 0 })]
		private readonly Element[] items;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0 })]
		private readonly Factory factory;

		internal ConcurrentObjectPool([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0 })] Factory factory)
			: this(factory, Environment.ProcessorCount * 2)
		{
		}

		internal ConcurrentObjectPool([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0 })] Factory factory, int size)
		{
			this.factory = factory;
			items = new Element[size - 1];
		}

		private T CreateInstance()
		{
			return factory();
		}

		internal T Allocate()
		{
			T val = firstItem;
			if (val == null || val != Interlocked.CompareExchange(ref firstItem, null, val))
			{
				val = AllocateSlow();
			}
			return val;
		}

		private T AllocateSlow()
		{
			Element[] array = items;
			for (int i = 0; i < array.Length; i++)
			{
				T value = array[i].value;
				if (value != null && value == Interlocked.CompareExchange(ref array[i].value, null, value))
				{
					return value;
				}
			}
			return CreateInstance();
		}

		internal void Free(T obj)
		{
			if (firstItem == null)
			{
				firstItem = obj;
			}
			else
			{
				FreeSlow(obj);
			}
		}

		private void FreeSlow(T obj)
		{
			Element[] array = items;
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].value == null)
				{
					array[i].value = obj;
					break;
				}
			}
		}

		[Conditional("DEBUG")]
		private void Validate(object obj)
		{
			Element[] array = items;
			for (int i = 0; i < array.Length && array[i].value != null; i++)
			{
			}
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal static class ExpressionExtensions
	{
		public static PropertyInfo AsProperty(this LambdaExpression propertyAccessor)
		{
			PropertyInfo propertyInfo = TryGetMemberExpression<PropertyInfo>(propertyAccessor);
			if (propertyInfo == null)
			{
				throw new ArgumentException("Expected a lambda expression in the form: x => x.SomeProperty", "propertyAccessor");
			}
			return propertyInfo;
		}

		[return: MaybeNull]
		private static TMemberInfo TryGetMemberExpression<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] TMemberInfo>(LambdaExpression lambdaExpression) where TMemberInfo : MemberInfo
		{
			if (lambdaExpression.Parameters.Count != 1)
			{
				return null;
			}
			Expression expression = lambdaExpression.Body;
			if (expression is UnaryExpression unaryExpression)
			{
				if (unaryExpression.NodeType != ExpressionType.Convert)
				{
					return null;
				}
				expression = unaryExpression.Operand;
			}
			if (expression is MemberExpression memberExpression)
			{
				if (memberExpression.Expression != lambdaExpression.Parameters[0])
				{
					return null;
				}
				return memberExpression.Member as TMemberInfo;
			}
			return null;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	internal sealed class GenericCollectionToNonGenericAdapter<T> : IList, ICollection, IEnumerable
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		private readonly ICollection<T> genericCollection;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object this[int index]
		{
			get
			{
				throw new NotSupportedException();
			}
			set
			{
				((IList<T>)genericCollection)[index] = (T)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public object SyncRoot
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
			get
			{
				throw new NotSupportedException();
			}
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public GenericCollectionToNonGenericAdapter(ICollection<T> genericCollection)
		{
			this.genericCollection = genericCollection ?? throw new ArgumentNullException("genericCollection");
		}

		public int Add(object value)
		{
			int count = genericCollection.Count;
			genericCollection.Add((T)value);
			return count;
		}

		public void Clear()
		{
			genericCollection.Clear();
		}

		public bool Contains(object value)
		{
			throw new NotSupportedException();
		}

		public int IndexOf(object value)
		{
			throw new NotSupportedException();
		}

		public void Insert(int index, object value)
		{
			throw new NotSupportedException();
		}

		public void Remove(object value)
		{
			throw new NotSupportedException();
		}

		public void RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public IEnumerator GetEnumerator()
		{
			return genericCollection.GetEnumerator();
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class GenericDictionaryToNonGenericAdapter<TKey, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TValue> : IDictionary, ICollection, IEnumerable
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class DictionaryEnumerator : IDictionaryEnumerator, IEnumerator
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })]
			private readonly IEnumerator<KeyValuePair<TKey, TValue>> enumerator;

			public DictionaryEntry Entry => new DictionaryEntry(Key, Value);

			public object Key => enumerator.Current.Key;

			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			public object Value
			{
				[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
				get
				{
					return enumerator.Current.Value;
				}
			}

			public object Current => Entry;

			public DictionaryEnumerator([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })] IEnumerator<KeyValuePair<TKey, TValue>> enumerator)
			{
				this.enumerator = enumerator;
			}

			public bool MoveNext()
			{
				return enumerator.MoveNext();
			}

			public void Reset()
			{
				enumerator.Reset();
			}
		}

		private readonly IDictionary<TKey, TValue> genericDictionary;

		public bool IsFixedSize
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsReadOnly
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Keys
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public ICollection Values
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public object this[object key]
		{
			[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			get
			{
				throw new NotSupportedException();
			}
			[param: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			set
			{
				genericDictionary[(TKey)key] = (TValue)value;
			}
		}

		public int Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public bool IsSynchronized
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public object SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public GenericDictionaryToNonGenericAdapter(IDictionary<TKey, TValue> genericDictionary)
		{
			this.genericDictionary = genericDictionary ?? throw new ArgumentNullException("genericDictionary");
		}

		public void Add(object key, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] object value)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public bool Contains(object key)
		{
			throw new NotSupportedException();
		}

		public IDictionaryEnumerator GetEnumerator()
		{
			return new DictionaryEnumerator(genericDictionary.GetEnumerator());
		}

		public void Remove(object key)
		{
			throw new NotSupportedException();
		}

		public void CopyTo(Array array, int index)
		{
			throw new NotSupportedException();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IOrderedDictionary<TKey, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TValue> : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })]
		KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })]
			get;
			[param: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })]
			set;
		}

		void Insert(int index, TKey key, TValue value);

		void RemoveAt(int index);
	}
	internal static class NumberExtensions
	{
		public static bool IsPowerOfTwo(this int value)
		{
			return (value & (value - 1)) == 0;
		}
	}
	[Serializable]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class OrderedDictionary<TKey, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TValue> : IOrderedDictionary<TKey, TValue>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class KeyCollection : ICollection<TKey>, IEnumerable<TKey>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TKey item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TKey item)
			{
				return orderedDictionary.dictionary.Keys.Contains(item);
			}

			public KeyCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TKey[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Key;
				}
			}

			public IEnumerator<TKey> GetEnumerator()
			{
				return orderedDictionary.list.Select([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (KeyValuePair<TKey, TValue> kvp) => kvp.Key).GetEnumerator();
			}

			public bool Remove(TKey item)
			{
				throw new NotSupportedException();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class ValueCollection : ICollection<TValue>, IEnumerable<TValue>, IEnumerable
		{
			private readonly OrderedDictionary<TKey, TValue> orderedDictionary;

			public int Count => orderedDictionary.list.Count;

			public bool IsReadOnly => true;

			public void Add(TValue item)
			{
				throw new NotSupportedException();
			}

			public void Clear()
			{
				throw new NotSupportedException();
			}

			public bool Contains(TValue item)
			{
				return orderedDictionary.dictionary.Values.Contains(item);
			}

			public ValueCollection(OrderedDictionary<TKey, TValue> orderedDictionary)
			{
				this.orderedDictionary = orderedDictionary;
			}

			public void CopyTo(TValue[] array, int arrayIndex)
			{
				for (int i = 0; i < orderedDictionary.list.Count; i++)
				{
					array[i] = orderedDictionary.list[i + arrayIndex].Value;
				}
			}

			public IEnumerator<TValue> GetEnumerator()
			{
				return orderedDictionary.list.Select([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (KeyValuePair<TKey, TValue> kvp) => kvp.Value).GetEnumerator();
			}

			public bool Remove(TValue item)
			{
				throw new NotSupportedException();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		[NonSerialized]
		private Dictionary<TKey, TValue> dictionary;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })]
		private readonly List<KeyValuePair<TKey, TValue>> list;

		private readonly IEqualityComparer<TKey> comparer;

		public TValue this[TKey key]
		{
			get
			{
				return dictionary[key];
			}
			set
			{
				if (dictionary.ContainsKey(key))
				{
					int index = list.FindIndex(([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
					dictionary[key] = value;
					list[index] = new KeyValuePair<TKey, TValue>(key, value);
				}
				else
				{
					Add(key, value);
				}
			}
		}

		public ICollection<TKey> Keys => new KeyCollection(this);

		public ICollection<TValue> Values => new ValueCollection(this);

		public int Count => dictionary.Count;

		public bool IsReadOnly => false;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })]
		public KeyValuePair<TKey, TValue> this[int index]
		{
			[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })]
			get
			{
				return list[index];
			}
			[param: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })]
			set
			{
				list[index] = value;
			}
		}

		public OrderedDictionary()
			: this((IEqualityComparer<TKey>)EqualityComparer<TKey>.Default)
		{
		}

		public OrderedDictionary(IEqualityComparer<TKey> comparer)
		{
			list = new List<KeyValuePair<TKey, TValue>>();
			dictionary = new Dictionary<TKey, TValue>(comparer);
			this.comparer = comparer;
		}

		public void Add(TKey key, TValue value)
		{
			Add(new KeyValuePair<TKey, TValue>(key, value));
		}

		public void Add([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			dictionary.Add(item.Key, item.Value);
			list.Add(item);
		}

		public void Clear()
		{
			dictionary.Clear();
			list.Clear();
		}

		public bool Contains([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			return dictionary.Contains(item);
		}

		public bool ContainsKey(TKey key)
		{
			return dictionary.ContainsKey(key);
		}

		public void CopyTo([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })] KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			list.CopyTo(array, arrayIndex);
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 1, 0, 1, 1 })]
		public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
		{
			return list.GetEnumerator();
		}

		public void Insert(int index, TKey key, TValue value)
		{
			dictionary.Add(key, value);
			list.Insert(index, new KeyValuePair<TKey, TValue>(key, value));
		}

		public bool Remove(TKey key)
		{
			if (dictionary.ContainsKey(key))
			{
				int index = list.FindIndex(([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> kvp) => comparer.Equals(kvp.Key, key));
				list.RemoveAt(index);
				if (!dictionary.Remove(key))
				{
					throw new InvalidOperationException();
				}
				return true;
			}
			return false;
		}

		public bool Remove([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })] KeyValuePair<TKey, TValue> item)
		{
			return Remove(item.Key);
		}

		public void RemoveAt(int index)
		{
			TKey key = list[index].Key;
			dictionary.Remove(key);
			list.RemoveAt(index);
		}

		public bool TryGetValue(TKey key, [MaybeNullWhen(false)] out TValue value)
		{
			return dictionary.TryGetValue(key, out value);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return list.GetEnumerator();
		}

		[System.Runtime.Serialization.OnDeserialized]
		internal void OnDeserializedMethod(StreamingContext context)
		{
			dictionary = new Dictionary<TKey, TValue>();
			foreach (KeyValuePair<TKey, TValue> item in list)
			{
				dictionary[item.Key] = item.Value;
			}
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[DebuggerStepThrough]
	internal static class StringBuilderPool
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		[<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly]
		internal struct BuilderWrapper : IDisposable
		{
			public readonly StringBuilder Builder;

			private readonly ConcurrentObjectPool<StringBuilder> _pool;

			public BuilderWrapper(StringBuilder builder, ConcurrentObjectPool<StringBuilder> pool)
			{
				Builder = builder;
				_pool = pool;
			}

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

			public void Dispose()
			{
				StringBuilder builder = Builder;
				if (builder.Capacity <= 1024)
				{
					builder.Length = 0;
					_pool.Free(builder);
				}
			}
		}

		private static readonly ConcurrentObjectPool<StringBuilder> Pool;

		static StringBuilderPool()
		{
			Pool = new ConcurrentObjectPool<StringBuilder>(() => new StringBuilder());
		}

		public static BuilderWrapper Rent()
		{
			return new BuilderWrapper(Pool.Allocate(), Pool);
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}
	}
	internal static class Lazy
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public static Lazy<T> FromValue<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(T value)
		{
			Lazy<T> lazy = new Lazy<T>(() => value, isThreadSafe: false);
			_ = lazy.Value;
			return lazy;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal static class ReadOnlyCollectionExtensions
	{
		public static IReadOnlyList<T> AsReadonlyList<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T>(this List<T> list)
		{
			return list;
		}

		public static IReadOnlyDictionary<TKey, TValue> AsReadonlyDictionary<TKey, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TValue>(this Dictionary<TKey, TValue> dictionary)
		{
			return dictionary;
		}
	}
}
namespace YamlDotNet.Core
{
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal struct AnchorName : IEquatable<AnchorName>
	{
		public static readonly AnchorName Empty = default(AnchorName);

		private static readonly Regex AnchorPattern = new Regex("^[^\\[\\]\\{\\},]+$", RegexOptions.Compiled);

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private readonly string value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of an empty anchor");

		public bool IsEmpty => value == null;

		public AnchorName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (!AnchorPattern.IsMatch(value))
			{
				throw new ArgumentException("Anchor cannot be empty or contain disallowed characters: []{},\nThe value was '" + value + "'.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "[empty]";
		}

		public bool Equals(AnchorName other)
		{
			return object.Equals(value, other.value);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is AnchorName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(AnchorName left, AnchorName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(AnchorName left, AnchorName right)
		{
			return !(left == right);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public static implicit operator AnchorName(string value)
		{
			if (value != null)
			{
				return new AnchorName(value);
			}
			return Empty;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class AnchorNotFoundException : YamlException
	{
		public AnchorNotFoundException(string message)
			: base(message)
		{
		}

		public AnchorNotFoundException([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end, string message)
			: base(ref start, ref end, message)
		{
		}

		public AnchorNotFoundException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[DebuggerStepThrough]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class CharacterAnalyzer<TBuffer> where TBuffer : class, ILookAheadBuffer
	{
		public TBuffer Buffer { get; }

		public bool EndOfInput => Buffer.EndOfInput;

		public CharacterAnalyzer(TBuffer buffer)
		{
			Buffer = buffer ?? throw new ArgumentNullException("buffer");
		}

		public char Peek(int offset)
		{
			return Buffer.Peek(offset);
		}

		public void Skip(int length)
		{
			Buffer.Skip(length);
		}

		public bool IsAlphaNumericDashOrUnderscore(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && c != '_')
			{
				return c == '-';
			}
			return true;
		}

		public bool IsAscii(int offset = 0)
		{
			return Buffer.Peek(offset) <= '\u007f';
		}

		public bool IsPrintable(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			switch (c)
			{
			default:
				if (c != '\u0085' && (c < '\u00a0' || c > '\ud7ff'))
				{
					if (c >= '\ue000')
					{
						return c <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		public bool IsDigit(int offset = 0)
		{
			char c = Buffer.Peek(offset);
			if (c >= '0')
			{
				return c <= '9';
			}
			return false;
		}

		public int AsDigit(int offset = 0)
		{
			return Buffer.Peek(offset) - 48;
		}

		public bool IsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if ((c < '0' || c > '9') && (c < 'A' || c > 'F'))
			{
				if (c >= 'a')
				{
					return c <= 'f';
				}
				return false;
			}
			return true;
		}

		public int AsHex(int offset)
		{
			char c = Buffer.Peek(offset);
			if (c <= '9')
			{
				return c - 48;
			}
			if (c <= 'F')
			{
				return c - 65 + 10;
			}
			return c - 97 + 10;
		}

		public bool IsSpace(int offset = 0)
		{
			return Check(' ', offset);
		}

		public bool IsZero(int offset = 0)
		{
			return Check('\0', offset);
		}

		public bool IsTab(int offset = 0)
		{
			return Check('\t', offset);
		}

		public bool IsWhite(int offset = 0)
		{
			if (!IsSpace(offset))
			{
				return IsTab(offset);
			}
			return true;
		}

		public bool IsBreak(int offset = 0)
		{
			return Check("\r\n\u0085\u2028\u2029", offset);
		}

		public bool IsCrLf(int offset = 0)
		{
			if (Check('\r', offset))
			{
				return Check('\n', offset + 1);
			}
			return false;
		}

		public bool IsBreakOrZero(int offset = 0)
		{
			if (!IsBreak(offset))
			{
				return IsZero(offset);
			}
			return true;
		}

		public bool IsWhiteBreakOrZero(int offset = 0)
		{
			if (!IsWhite(offset))
			{
				return IsBreakOrZero(offset);
			}
			return true;
		}

		public bool Check(char expected, int offset = 0)
		{
			return Buffer.Peek(offset) == expected;
		}

		public bool Check(string expectedCharacters, int offset = 0)
		{
			char value = Buffer.Peek(offset);
			return expectedCharacters.IndexOf(value) != -1;
		}
	}
	internal static class Constants
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		public static readonly TagDirective[] DefaultTagDirectives = new TagDirective[2]
		{
			new TagDirective("!", "!"),
			new TagDirective("!!", "tag:yaml.org,2002:")
		};

		public const int MajorVersion = 1;

		public const int MinorVersion = 3;
	}
	[DebuggerStepThrough]
	internal sealed class Cursor
	{
		public int Index { get; private set; }

		public int Line { get; private set; }

		public int LineOffset { get; private set; }

		public Cursor()
		{
			Line = 1;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public Cursor(Cursor cursor)
		{
			Index = cursor.Index;
			Line = cursor.Line;
			LineOffset = cursor.LineOffset;
		}

		public Mark Mark()
		{
			return new Mark(Index, Line, LineOffset + 1);
		}

		public void Skip()
		{
			Index++;
			LineOffset++;
		}

		public void SkipLineByOffset(int offset)
		{
			Index += offset;
			Line++;
			LineOffset = 0;
		}

		public void ForceSkipLineAfterNonBreak()
		{
			if (LineOffset != 0)
			{
				Line++;
				LineOffset = 0;
			}
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class Emitter : IEmitter
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		private class AnchorData
		{
			public AnchorName Anchor;

			public bool IsAlias;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class TagData
		{
			public string Handle;

			public string Suffix;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		private class ScalarData
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
			public string Value = string.Empty;

			public bool IsMultiline;

			public bool IsFlowPlainAllowed;

			public bool IsBlockPlainAllowed;

			public bool IsSingleQuotedAllowed;

			public bool IsBlockAllowed;

			public bool HasSingleQuotes;

			public ScalarStyle Style;
		}

		private static readonly Regex UriReplacer = new Regex("[^0-9A-Za-z_\\-;?@=$~\\\\\\)\\]/:&+,\\.\\*\\(\\[!]", RegexOptions.Compiled | RegexOptions.Singleline);

		private static readonly string[] newLineSeparators = new string[3] { "\r\n", "\r", "\n" };

		private readonly TextWriter output;

		private readonly bool outputUsesUnicodeEncoding;

		private readonly int maxSimpleKeyLength;

		private readonly bool isCanonical;

		private readonly bool skipAnchorName;

		private readonly int bestIndent;

		private readonly int bestWidth;

		private EmitterState state;

		private readonly Stack<EmitterState> states = new Stack<EmitterState>();

		private readonly Queue<ParsingEvent> events = new Queue<ParsingEvent>();

		private readonly Stack<int> indents = new Stack<int>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private int indent;

		private int flowLevel;

		private bool isMappingContext;

		private bool isSimpleKeyContext;

		private int column;

		private bool isWhitespace;

		private bool isIndentation;

		private readonly bool forceIndentLess;

		private readonly string newLine;

		private bool isDocumentEndWritten;

		private readonly AnchorData anchorData = new AnchorData();

		private readonly TagData tagData = new TagData();

		private readonly ScalarData scalarData = new ScalarData();

		public Emitter(TextWriter output)
			: this(output, EmitterSettings.Default)
		{
		}

		public Emitter(TextWriter output, int bestIndent)
			: this(output, bestIndent, int.MaxValue)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth)
			: this(output, bestIndent, bestWidth, isCanonical: false)
		{
		}

		public Emitter(TextWriter output, int bestIndent, int bestWidth, bool isCanonical)
			: this(output, new EmitterSettings(bestIndent, bestWidth, isCanonical, 1024))
		{
		}

		public Emitter(TextWriter output, EmitterSettings settings)
		{
			bestIndent = settings.BestIndent;
			bestWidth = settings.BestWidth;
			isCanonical = settings.IsCanonical;
			maxSimpleKeyLength = settings.MaxSimpleKeyLength;
			skipAnchorName = settings.SkipAnchorName;
			forceIndentLess = !settings.IndentSequences;
			newLine = settings.NewLine;
			this.output = output;
			outputUsesUnicodeEncoding = IsUnicode(output.Encoding);
		}

		public void Emit(ParsingEvent @event)
		{
			events.Enqueue(@event);
			while (!NeedMoreEvents())
			{
				ParsingEvent evt = events.Peek();
				try
				{
					AnalyzeEvent(evt);
					StateMachine(evt);
				}
				finally
				{
					events.Dequeue();
				}
			}
		}

		private bool NeedMoreEvents()
		{
			if (events.Count == 0)
			{
				return true;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.DocumentStart:
				num = 1;
				break;
			case EventType.SequenceStart:
				num = 2;
				break;
			case EventType.MappingStart:
				num = 3;
				break;
			default:
				return false;
			}
			if (events.Count > num)
			{
				return false;
			}
			int num2 = 0;
			using (Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					switch (enumerator.Current.Type)
					{
					case EventType.DocumentStart:
					case EventType.SequenceStart:
					case EventType.MappingStart:
						num2++;
						break;
					case EventType.DocumentEnd:
					case EventType.SequenceEnd:
					case EventType.MappingEnd:
						num2--;
						break;
					}
					if (num2 == 0)
					{
						return false;
					}
				}
			}
			return true;
		}

		private void AnalyzeEvent(ParsingEvent evt)
		{
			anchorData.Anchor = AnchorName.Empty;
			tagData.Handle = null;
			tagData.Suffix = null;
			if (evt is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				AnalyzeAnchor(anchorAlias.Value, isAlias: true);
			}
			else if (evt is NodeEvent nodeEvent)
			{
				if (evt is YamlDotNet.Core.Events.Scalar scalar)
				{
					AnalyzeScalar(scalar);
				}
				AnalyzeAnchor(nodeEvent.Anchor, isAlias: false);
				if (!nodeEvent.Tag.IsEmpty && (isCanonical || nodeEvent.IsCanonical))
				{
					AnalyzeTag(nodeEvent.Tag);
				}
			}
		}

		private void AnalyzeAnchor(AnchorName anchor, bool isAlias)
		{
			anchorData.Anchor = anchor;
			anchorData.IsAlias = isAlias;
		}

		private void AnalyzeScalar(YamlDotNet.Core.Events.Scalar scalar)
		{
			string value = scalar.Value;
			scalarData.Value = value;
			if (value.Length == 0)
			{
				if (scalar.Tag == "tag:yaml.org,2002:null")
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = true;
					scalarData.IsSingleQuotedAllowed = false;
					scalarData.IsBlockAllowed = false;
				}
				else
				{
					scalarData.IsMultiline = false;
					scalarData.IsFlowPlainAllowed = false;
					scalarData.IsBlockPlainAllowed = false;
					scalarData.IsSingleQuotedAllowed = true;
					scalarData.IsBlockAllowed = false;
				}
				return;
			}
			bool flag = false;
			bool flag2 = false;
			if (value.StartsWith("---", StringComparison.Ordinal) || value.StartsWith("...", StringComparison.Ordinal))
			{
				flag = true;
				flag2 = true;
			}
			CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(new StringLookAheadBuffer(value));
			bool flag3 = true;
			bool flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
			bool flag5 = false;
			bool flag6 = false;
			bool flag7 = false;
			bool flag8 = false;
			bool flag9 = false;
			bool flag10 = false;
			bool flag11 = false;
			bool flag12 = false;
			bool flag13 = false;
			bool flag14 = false;
			bool flag15 = false;
			bool flag16 = !ValueIsRepresentableInOutputEncoding(value);
			bool flag17 = false;
			bool flag18 = false;
			bool flag19 = true;
			while (!characterAnalyzer.EndOfInput)
			{
				if (flag19)
				{
					if (characterAnalyzer.Check("#,[]{}&*!|>\\\"%@`'"))
					{
						flag = true;
						flag2 = true;
						flag9 = characterAnalyzer.Check('\'');
						flag17 |= characterAnalyzer.Check('\'');
					}
					if (characterAnalyzer.Check("?:"))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (characterAnalyzer.Check('-') && flag4)
					{
						flag = true;
						flag2 = true;
					}
				}
				else
				{
					if (characterAnalyzer.Check(",?[]{}"))
					{
						flag = true;
					}
					if (characterAnalyzer.Check(':'))
					{
						flag = true;
						if (flag4)
						{
							flag2 = true;
						}
					}
					if (characterAnalyzer.Check('#') && flag3)
					{
						flag = true;
						flag2 = true;
					}
					flag17 |= characterAnalyzer.Check('\'');
				}
				if (!flag16 && !characterAnalyzer.IsPrintable())
				{
					flag16 = true;
				}
				if (characterAnalyzer.IsBreak())
				{
					flag15 = true;
				}
				if (characterAnalyzer.IsSpace())
				{
					if (flag19)
					{
						flag5 = true;
					}
					if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
					{
						flag7 = true;
					}
					if (flag13)
					{
						flag10 = true;
						flag14 = true;
					}
					flag12 = true;
					flag13 = false;
				}
				else if (characterAnalyzer.IsBreak())
				{
					if (flag19)
					{
						flag6 = true;
					}
					if (characterAnalyzer.Buffer.Position >= characterAnalyzer.Buffer.Length - 1)
					{
						flag8 = true;
					}
					if (flag12)
					{
						flag11 = true;
					}
					if (flag14)
					{
						flag18 = true;
					}
					flag12 = false;
					flag13 = true;
				}
				else
				{
					flag12 = false;
					flag13 = false;
					flag14 = false;
				}
				flag3 = characterAnalyzer.IsWhiteBreakOrZero();
				characterAnalyzer.Skip(1);
				if (!characterAnalyzer.EndOfInput)
				{
					flag4 = characterAnalyzer.IsWhiteBreakOrZero(1);
				}
				flag19 = false;
			}
			scalarData.IsFlowPlainAllowed = true;
			scalarData.IsBlockPlainAllowed = true;
			scalarData.IsSingleQuotedAllowed = true;
			scalarData.IsBlockAllowed = true;
			if (flag5 || flag6 || flag7 || flag8 || flag9)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
			}
			if (flag7)
			{
				scalarData.IsBlockAllowed = false;
			}
			if (flag10)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
				scalarData.IsSingleQuotedAllowed = false;
			}
			if (flag11 || flag16)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
				scalarData.IsSingleQuotedAllowed = false;
			}
			if (flag18)
			{
				scalarData.IsBlockAllowed = false;
			}
			scalarData.IsMultiline = flag15;
			if (flag15)
			{
				scalarData.IsFlowPlainAllowed = false;
				scalarData.IsBlockPlainAllowed = false;
			}
			if (flag)
			{
				scalarData.IsFlowPlainAllowed = false;
			}
			if (flag2)
			{
				scalarData.IsBlockPlainAllowed = false;
			}
			scalarData.HasSingleQuotes = flag17;
		}

		private bool ValueIsRepresentableInOutputEncoding(string value)
		{
			if (outputUsesUnicodeEncoding)
			{
				return true;
			}
			try
			{
				byte[] bytes = output.Encoding.GetBytes(value);
				return output.Encoding.GetString(bytes, 0, bytes.Length).Equals(value);
			}
			catch (EncoderFallbackException)
			{
				return false;
			}
			catch (ArgumentOutOfRangeException)
			{
				return false;
			}
		}

		private bool IsUnicode(Encoding encoding)
		{
			if (!(encoding is UTF8Encoding) && !(encoding is UnicodeEncoding))
			{
				return encoding is UTF7Encoding;
			}
			return true;
		}

		private void AnalyzeTag(TagName tag)
		{
			tagData.Handle = tag.Value;
			foreach (TagDirective tagDirective in tagDirectives)
			{
				if (tag.Value.StartsWith(tagDirective.Prefix, StringComparison.Ordinal))
				{
					tagData.Handle = tagDirective.Handle;
					tagData.Suffix = tag.Value.Substring(tagDirective.Prefix.Length);
					break;
				}
			}
		}

		private void StateMachine(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.Comment comment)
			{
				EmitComment(comment);
				return;
			}
			switch (state)
			{
			case EmitterState.StreamStart:
				EmitStreamStart(evt);
				break;
			case EmitterState.FirstDocumentStart:
				EmitDocumentStart(evt, isFirst: true);
				break;
			case EmitterState.DocumentStart:
				EmitDocumentStart(evt, isFirst: false);
				break;
			case EmitterState.DocumentContent:
				EmitDocumentContent(evt);
				break;
			case EmitterState.DocumentEnd:
				EmitDocumentEnd(evt);
				break;
			case EmitterState.FlowSequenceFirstItem:
				EmitFlowSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.FlowSequenceItem:
				EmitFlowSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingFirstKey:
				EmitFlowMappingKey(evt, isFirst: true);
				break;
			case EmitterState.FlowMappingKey:
				EmitFlowMappingKey(evt, isFirst: false);
				break;
			case EmitterState.FlowMappingSimpleValue:
				EmitFlowMappingValue(evt, isSimple: true);
				break;
			case EmitterState.FlowMappingValue:
				EmitFlowMappingValue(evt, isSimple: false);
				break;
			case EmitterState.BlockSequenceFirstItem:
				EmitBlockSequenceItem(evt, isFirst: true);
				break;
			case EmitterState.BlockSequenceItem:
				EmitBlockSequenceItem(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingFirstKey:
				EmitBlockMappingKey(evt, isFirst: true);
				break;
			case EmitterState.BlockMappingKey:
				EmitBlockMappingKey(evt, isFirst: false);
				break;
			case EmitterState.BlockMappingSimpleValue:
				EmitBlockMappingValue(evt, isSimple: true);
				break;
			case EmitterState.BlockMappingValue:
				EmitBlockMappingValue(evt, isSimple: false);
				break;
			case EmitterState.StreamEnd:
				throw new YamlException("Expected nothing after STREAM-END");
			default:
				throw new InvalidOperationException();
			}
		}

		private void EmitComment(YamlDotNet.Core.Events.Comment comment)
		{
			if (flowLevel > 0 || state == EmitterState.FlowMappingFirstKey || state == EmitterState.FlowSequenceFirstItem)
			{
				return;
			}
			string[] array = comment.Value.Split(newLineSeparators, StringSplitOptions.None);
			if (comment.IsInline)
			{
				Write(" # ");
				Write(string.Join(" ", array));
			}
			else
			{
				bool flag = state == EmitterState.BlockMappingFirstKey;
				if (flag)
				{
					IncreaseIndent(isFlow: false, isIndentless: false);
				}
				string[] array2 = array;
				foreach (string value in array2)
				{
					WriteIndent();
					Write("# ");
					Write(value);
					WriteBreak();
				}
				if (flag)
				{
					indent = indents.Pop();
				}
			}
			isIndentation = true;
		}

		private void EmitStreamStart(ParsingEvent evt)
		{
			if (!(evt is YamlDotNet.Core.Events.StreamStart))
			{
				throw new ArgumentException("Expected STREAM-START.", "evt");
			}
			indent = -1;
			column = 0;
			isWhitespace = true;
			isIndentation = true;
			state = EmitterState.FirstDocumentStart;
		}

		private void EmitDocumentStart(ParsingEvent evt, bool isFirst)
		{
			if (evt is YamlDotNet.Core.Events.DocumentStart documentStart)
			{
				bool flag = documentStart.IsImplicit && isFirst && !isCanonical;
				TagDirectiveCollection tagDirectiveCollection = NonDefaultTagsAmong(documentStart.Tags);
				if (!isFirst && !isDocumentEndWritten && (documentStart.Version != null || tagDirectiveCollection.Count > 0))
				{
					isDocumentEndWritten = false;
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				if (documentStart.Version != null)
				{
					AnalyzeVersionDirective(documentStart.Version);
					Version version = documentStart.Version.Version;
					flag = false;
					WriteIndicator("%YAML", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndicator(string.Format(CultureInfo.InvariantCulture, "{0}.{1}", version.Major, version.Minor), needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
				}
				foreach (TagDirective item in tagDirectiveCollection)
				{
					AppendTagDirectiveTo(item, allowDuplicates: false, tagDirectives);
				}
				TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
				for (int i = 0; i < defaultTagDirectives.Length; i++)
				{
					AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, tagDirectives);
				}
				if (tagDirectiveCollection.Count > 0)
				{
					flag = false;
					defaultTagDirectives = Constants.DefaultTagDirectives;
					for (int i = 0; i < defaultTagDirectives.Length; i++)
					{
						AppendTagDirectiveTo(defaultTagDirectives[i], allowDuplicates: true, tagDirectiveCollection);
					}
					foreach (TagDirective item2 in tagDirectiveCollection)
					{
						WriteIndicator("%TAG", needWhitespace: true, whitespace: false, indentation: false);
						WriteTagHandle(item2.Handle);
						WriteTagContent(item2.Prefix, needsWhitespace: true);
						WriteIndent();
					}
				}
				if (CheckEmptyDocument())
				{
					flag = false;
				}
				if (!flag)
				{
					WriteIndent();
					WriteIndicator("---", needWhitespace: true, whitespace: false, indentation: false);
					if (isCanonical)
					{
						WriteIndent();
					}
				}
				state = EmitterState.DocumentContent;
			}
			else
			{
				if (!(evt is YamlDotNet.Core.Events.StreamEnd))
				{
					throw new YamlException("Expected DOCUMENT-START or STREAM-END");
				}
				state = EmitterState.StreamEnd;
			}
		}

		private TagDirectiveCollection NonDefaultTagsAmong([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })] IEnumerable<TagDirective> tagCollection)
		{
			TagDirectiveCollection tagDirectiveCollection = new TagDirectiveCollection();
			if (tagCollection == null)
			{
				return tagDirectiveCollection;
			}
			foreach (TagDirective item2 in tagCollection)
			{
				AppendTagDirectiveTo(item2, allowDuplicates: false, tagDirectiveCollection);
			}
			TagDirective[] defaultTagDirectives = Constants.DefaultTagDirectives;
			foreach (TagDirective item in defaultTagDirectives)
			{
				tagDirectiveCollection.Remove(item);
			}
			return tagDirectiveCollection;
		}

		private void AnalyzeVersionDirective(VersionDirective versionDirective)
		{
			if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
			{
				throw new YamlException("Incompatible %YAML directive");
			}
		}

		private static void AppendTagDirectiveTo(TagDirective value, bool allowDuplicates, TagDirectiveCollection tagDirectives)
		{
			if (tagDirectives.Contains(value))
			{
				if (!allowDuplicates)
				{
					throw new YamlException("Duplicate %TAG directive.");
				}
			}
			else
			{
				tagDirectives.Add(value);
			}
		}

		private void EmitDocumentContent(ParsingEvent evt)
		{
			states.Push(EmitterState.DocumentEnd);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitNode(ParsingEvent evt, bool isMapping, bool isSimpleKey)
		{
			isMappingContext = isMapping;
			isSimpleKeyContext = isSimpleKey;
			switch (evt.Type)
			{
			case EventType.Alias:
				EmitAlias();
				break;
			case EventType.Scalar:
				EmitScalar(evt);
				break;
			case EventType.SequenceStart:
				EmitSequenceStart(evt);
				break;
			case EventType.MappingStart:
				EmitMappingStart(evt);
				break;
			default:
				throw new YamlException($"Expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS, got {evt.Type}");
			}
		}

		private void EmitAlias()
		{
			ProcessAnchor();
			state = states.Pop();
		}

		private void EmitScalar(ParsingEvent evt)
		{
			SelectScalarStyle(evt);
			ProcessAnchor();
			ProcessTag();
			IncreaseIndent(isFlow: true, isIndentless: false);
			ProcessScalar();
			indent = indents.Pop();
			state = states.Pop();
		}

		private void SelectScalarStyle(ParsingEvent evt)
		{
			YamlDotNet.Core.Events.Scalar scalar = (YamlDotNet.Core.Events.Scalar)evt;
			ScalarStyle scalarStyle = scalar.Style;
			bool flag = tagData.Handle == null && tagData.Suffix == null;
			if (flag && !scalar.IsPlainImplicit && !scalar.IsQuotedImplicit)
			{
				throw new YamlException("Neither tag nor isImplicit flags are specified.");
			}
			if (scalarStyle == ScalarStyle.Any)
			{
				scalarStyle = ((!scalarData.IsMultiline) ? ScalarStyle.Plain : ScalarStyle.Folded);
			}
			if (isCanonical)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (isSimpleKeyContext && scalarData.IsMultiline)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if (scalarStyle == ScalarStyle.Plain)
			{
				if ((flowLevel != 0 && !scalarData.IsFlowPlainAllowed) || (flowLevel == 0 && !scalarData.IsBlockPlainAllowed))
				{
					scalarStyle = ((scalarData.IsSingleQuotedAllowed && !scalarData.HasSingleQuotes) ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted);
				}
				if (string.IsNullOrEmpty(scalarData.Value) && (flowLevel != 0 || isSimpleKeyContext))
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
				if (flag && !scalar.IsPlainImplicit)
				{
					scalarStyle = ScalarStyle.SingleQuoted;
				}
			}
			if (scalarStyle == ScalarStyle.SingleQuoted && !scalarData.IsSingleQuotedAllowed)
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			if ((scalarStyle == ScalarStyle.Literal || scalarStyle == ScalarStyle.Folded) && (!scalarData.IsBlockAllowed || flowLevel != 0 || isSimpleKeyContext))
			{
				scalarStyle = ScalarStyle.DoubleQuoted;
			}
			scalarData.Style = scalarStyle;
		}

		private void ProcessScalar()
		{
			switch (scalarData.Style)
			{
			case ScalarStyle.Plain:
				WritePlainScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.SingleQuoted:
				WriteSingleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.DoubleQuoted:
				WriteDoubleQuotedScalar(scalarData.Value, !isSimpleKeyContext);
				break;
			case ScalarStyle.Literal:
				WriteLiteralScalar(scalarData.Value);
				break;
			case ScalarStyle.Folded:
				WriteFoldedScalar(scalarData.Value);
				break;
			default:
				throw new InvalidOperationException();
			}
		}

		private void WritePlainScalar(string value, bool allowBreaks)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsSpace(c))
				{
					if (allowBreaks && !flag && column > bestWidth && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteSingleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("'", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			bool flag2 = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == ' ')
				{
					if (allowBreaks && !flag && column > bestWidth && i != 0 && i + 1 < value.Length && value[i + 1] != ' ')
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					flag = true;
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					if (!flag2 && c == '\n')
					{
						WriteBreak();
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag2 = true;
					continue;
				}
				if (flag2)
				{
					WriteIndent();
				}
				if (c == '\'')
				{
					Write(c);
				}
				Write(c);
				isIndentation = false;
				flag = false;
				flag2 = false;
			}
			WriteIndicator("'", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteDoubleQuotedScalar(string value, bool allowBreaks)
		{
			WriteIndicator("\"", needWhitespace: true, whitespace: false, indentation: false);
			bool flag = false;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsPrintable(c) && !IsBreak(c, out var _))
				{
					switch (c)
					{
					case '"':
					case '\\':
						break;
					case ' ':
						if (allowBreaks && !flag && column > bestWidth && i > 0 && i + 1 < value.Length)
						{
							WriteIndent();
							if (value[i + 1] == ' ')
							{
								Write('\\');
							}
						}
						else
						{
							Write(c);
						}
						flag = true;
						continue;
					default:
						Write(c);
						flag = false;
						continue;
					}
				}
				Write('\\');
				switch (c)
				{
				case '\0':
					Write('0');
					break;
				case '\a':
					Write('a');
					break;
				case '\b':
					Write('b');
					break;
				case '\t':
					Write('t');
					break;
				case '\n':
					Write('n');
					break;
				case '\v':
					Write('v');
					break;
				case '\f':
					Write('f');
					break;
				case '\r':
					Write('r');
					break;
				case '\u001b':
					Write('e');
					break;
				case '"':
					Write('"');
					break;
				case '\\':
					Write('\\');
					break;
				case '\u0085':
					Write('N');
					break;
				case '\u00a0':
					Write('_');
					break;
				case '\u2028':
					Write('L');
					break;
				case '\u2029':
					Write('P');
					break;
				default:
				{
					ushort num = c;
					if (num <= 255)
					{
						Write('x');
						Write(num.ToString("X02", CultureInfo.InvariantCulture));
					}
					else if (IsHighSurrogate(c))
					{
						if (i + 1 >= value.Length || !IsLowSurrogate(value[i + 1]))
						{
							throw new SyntaxErrorException("While writing a quoted scalar, found an orphaned high surrogate.");
						}
						Write('U');
						Write(char.ConvertToUtf32(c, value[i + 1]).ToString("X08", CultureInfo.InvariantCulture));
						i++;
					}
					else
					{
						Write('u');
						Write(num.ToString("X04", CultureInfo.InvariantCulture));
					}
					break;
				}
				}
				flag = false;
			}
			WriteIndicator("\"", needWhitespace: false, whitespace: false, indentation: false);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteLiteralScalar(string value)
		{
			bool flag = true;
			WriteIndicator("|", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
				{
					continue;
				}
				if (IsBreak(c, out var breakChar))
				{
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
					continue;
				}
				if (flag)
				{
					WriteIndent();
				}
				Write(c);
				isIndentation = false;
				flag = false;
			}
		}

		private void WriteFoldedScalar(string value)
		{
			bool flag = true;
			bool flag2 = true;
			WriteIndicator(">", needWhitespace: true, whitespace: false, indentation: false);
			WriteBlockScalarHints(value);
			WriteBreak();
			isIndentation = true;
			isWhitespace = true;
			for (int i = 0; i < value.Length; i++)
			{
				char c = value[i];
				if (IsBreak(c, out var breakChar))
				{
					if (c == '\r' && i + 1 < value.Length && value[i + 1] == '\n')
					{
						continue;
					}
					if (!flag && !flag2 && breakChar == '\n')
					{
						int j;
						char breakChar2;
						for (j = 0; i + j < value.Length && IsBreak(value[i + j], out breakChar2); j++)
						{
						}
						if (i + j < value.Length && !IsBlank(value[i + j]) && !IsBreak(value[i + j], out breakChar2))
						{
							WriteBreak();
						}
					}
					WriteBreak(breakChar);
					isIndentation = true;
					flag = true;
				}
				else
				{
					if (flag)
					{
						WriteIndent();
						flag2 = IsBlank(c);
					}
					if (!flag && c == ' ' && i + 1 < value.Length && value[i + 1] != ' ' && column > bestWidth)
					{
						WriteIndent();
					}
					else
					{
						Write(c);
					}
					isIndentation = false;
					flag = false;
				}
			}
		}

		private static bool IsSpace(char character)
		{
			return character == ' ';
		}

		private static bool IsBreak(char character, out char breakChar)
		{
			switch (character)
			{
			case '\n':
			case '\r':
			case '\u0085':
				breakChar = '\n';
				return true;
			case '\u2028':
			case '\u2029':
				breakChar = character;
				return true;
			default:
				breakChar = '\0';
				return false;
			}
		}

		private static bool IsBlank(char character)
		{
			if (character != ' ')
			{
				return character == '\t';
			}
			return true;
		}

		private static bool IsPrintable(char character)
		{
			switch (character)
			{
			default:
				if (character != '\u0085' && (character < '\u00a0' || character > '\ud7ff'))
				{
					if (character >= '\ue000')
					{
						return character <= '\ufffd';
					}
					return false;
				}
				break;
			case '\t':
			case '\n':
			case '\r':
			case ' ':
			case '!':
			case '"':
			case '#':
			case '$':
			case '%':
			case '&':
			case '\'':
			case '(':
			case ')':
			case '*':
			case '+':
			case ',':
			case '-':
			case '.':
			case '/':
			case '0':
			case '1':
			case '2':
			case '3':
			case '4':
			case '5':
			case '6':
			case '7':
			case '8':
			case '9':
			case ':':
			case ';':
			case '<':
			case '=':
			case '>':
			case '?':
			case '@':
			case 'A':
			case 'B':
			case 'C':
			case 'D':
			case 'E':
			case 'F':
			case 'G':
			case 'H':
			case 'I':
			case 'J':
			case 'K':
			case 'L':
			case 'M':
			case 'N':
			case 'O':
			case 'P':
			case 'Q':
			case 'R':
			case 'S':
			case 'T':
			case 'U':
			case 'V':
			case 'W':
			case 'X':
			case 'Y':
			case 'Z':
			case '[':
			case '\\':
			case ']':
			case '^':
			case '_':
			case '`':
			case 'a':
			case 'b':
			case 'c':
			case 'd':
			case 'e':
			case 'f':
			case 'g':
			case 'h':
			case 'i':
			case 'j':
			case 'k':
			case 'l':
			case 'm':
			case 'n':
			case 'o':
			case 'p':
			case 'q':
			case 'r':
			case 's':
			case 't':
			case 'u':
			case 'v':
			case 'w':
			case 'x':
			case 'y':
			case 'z':
			case '{':
			case '|':
			case '}':
			case '~':
				break;
			}
			return true;
		}

		private static bool IsHighSurrogate(char c)
		{
			if ('\ud800' <= c)
			{
				return c <= '\udbff';
			}
			return false;
		}

		private static bool IsLowSurrogate(char c)
		{
			if ('\udc00' <= c)
			{
				return c <= '\udfff';
			}
			return false;
		}

		private void EmitSequenceStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			SequenceStart sequenceStart = (SequenceStart)evt;
			if (flowLevel != 0 || isCanonical || sequenceStart.Style == SequenceStyle.Flow || CheckEmptySequence())
			{
				state = EmitterState.FlowSequenceFirstItem;
			}
			else
			{
				state = EmitterState.BlockSequenceFirstItem;
			}
		}

		private void EmitMappingStart(ParsingEvent evt)
		{
			ProcessAnchor();
			ProcessTag();
			MappingStart mappingStart = (MappingStart)evt;
			if (flowLevel != 0 || isCanonical || mappingStart.Style == MappingStyle.Flow || CheckEmptyMapping())
			{
				state = EmitterState.FlowMappingFirstKey;
			}
			else
			{
				state = EmitterState.BlockMappingFirstKey;
			}
		}

		private void ProcessAnchor()
		{
			if (!anchorData.Anchor.IsEmpty && !skipAnchorName)
			{
				WriteIndicator(anchorData.IsAlias ? "*" : "&", needWhitespace: true, whitespace: false, indentation: false);
				WriteAnchor(anchorData.Anchor);
			}
		}

		private void ProcessTag()
		{
			if (tagData.Handle == null && tagData.Suffix == null)
			{
				return;
			}
			if (tagData.Handle != null)
			{
				WriteTagHandle(tagData.Handle);
				if (tagData.Suffix != null)
				{
					WriteTagContent(tagData.Suffix, needsWhitespace: false);
				}
			}
			else
			{
				WriteIndicator("!<", needWhitespace: true, whitespace: false, indentation: false);
				WriteTagContent(tagData.Suffix, needsWhitespace: false);
				WriteIndicator(">", needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		private void EmitDocumentEnd(ParsingEvent evt)
		{
			if (evt is YamlDotNet.Core.Events.DocumentEnd documentEnd)
			{
				WriteIndent();
				if (!documentEnd.IsImplicit)
				{
					WriteIndicator("...", needWhitespace: true, whitespace: false, indentation: false);
					WriteIndent();
					isDocumentEndWritten = true;
				}
				state = EmitterState.DocumentStart;
				tagDirectives.Clear();
				return;
			}
			throw new YamlException("Expected DOCUMENT-END.");
		}

		private void EmitFlowSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("[", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is SequenceEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("]", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
			}
			else
			{
				if (!isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
				}
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				states.Push(EmitterState.FlowSequenceItem);
				EmitNode(evt, isMapping: false, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				WriteIndicator("{", needWhitespace: true, whitespace: true, indentation: false);
				IncreaseIndent(isFlow: true, isIndentless: false);
				flowLevel++;
			}
			if (evt is MappingEnd)
			{
				flowLevel--;
				indent = indents.Pop();
				if (isCanonical && !isFirst)
				{
					WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
					WriteIndent();
				}
				WriteIndicator("}", needWhitespace: false, whitespace: false, indentation: false);
				state = states.Pop();
				return;
			}
			if (!isFirst)
			{
				WriteIndicator(",", needWhitespace: false, whitespace: false, indentation: false);
			}
			if (isCanonical || column > bestWidth)
			{
				WriteIndent();
			}
			if (!isCanonical && CheckSimpleKey())
			{
				states.Push(EmitterState.FlowMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: false);
				states.Push(EmitterState.FlowMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitFlowMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (isSimple)
			{
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				if (isCanonical || column > bestWidth)
				{
					WriteIndent();
				}
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: false);
			}
			states.Push(EmitterState.FlowMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void EmitBlockSequenceItem(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isMappingContext && !isIndentation);
			}
			if (evt is SequenceEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			WriteIndicator("-", needWhitespace: true, whitespace: false, indentation: true);
			states.Push(EmitterState.BlockSequenceItem);
			EmitNode(evt, isMapping: false, isSimpleKey: false);
		}

		private void EmitBlockMappingKey(ParsingEvent evt, bool isFirst)
		{
			if (isFirst)
			{
				IncreaseIndent(isFlow: false, isIndentless: false);
			}
			if (evt is MappingEnd)
			{
				indent = indents.Pop();
				state = states.Pop();
				return;
			}
			WriteIndent();
			if (CheckSimpleKey())
			{
				states.Push(EmitterState.BlockMappingSimpleValue);
				EmitNode(evt, isMapping: true, isSimpleKey: true);
				WriteIndicator(":", needWhitespace: false, whitespace: false, indentation: false);
			}
			else
			{
				WriteIndicator("?", needWhitespace: true, whitespace: false, indentation: true);
				states.Push(EmitterState.BlockMappingValue);
				EmitNode(evt, isMapping: true, isSimpleKey: false);
			}
		}

		private void EmitBlockMappingValue(ParsingEvent evt, bool isSimple)
		{
			if (!isSimple)
			{
				WriteIndent();
				WriteIndicator(":", needWhitespace: true, whitespace: false, indentation: true);
			}
			states.Push(EmitterState.BlockMappingKey);
			EmitNode(evt, isMapping: true, isSimpleKey: false);
		}

		private void IncreaseIndent(bool isFlow, bool isIndentless)
		{
			indents.Push(indent);
			if (indent < 0)
			{
				indent = (isFlow ? bestIndent : 0);
			}
			else if (!isIndentless || !forceIndentLess)
			{
				indent += bestIndent;
			}
		}

		private bool CheckEmptyDocument()
		{
			int num = 0;
			foreach (ParsingEvent @event in events)
			{
				num++;
				if (num == 2)
				{
					if (@event is YamlDotNet.Core.Events.Scalar scalar)
					{
						return string.IsNullOrEmpty(scalar.Value);
					}
					break;
				}
			}
			return false;
		}

		private bool CheckSimpleKey()
		{
			if (events.Count < 1)
			{
				return false;
			}
			int num;
			switch (events.Peek().Type)
			{
			case EventType.Alias:
				num = AnchorNameLength(anchorData.Anchor);
				break;
			case EventType.Scalar:
				if (scalarData.IsMultiline)
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix) + SafeStringLength(scalarData.Value);
				break;
			case EventType.SequenceStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			case EventType.MappingStart:
				if (!CheckEmptySequence())
				{
					return false;
				}
				num = AnchorNameLength(anchorData.Anchor) + SafeStringLength(tagData.Handle) + SafeStringLength(tagData.Suffix);
				break;
			default:
				return false;
			}
			return num <= maxSimpleKeyLength;
		}

		private int AnchorNameLength(AnchorName value)
		{
			if (!value.IsEmpty)
			{
				return value.Value.Length;
			}
			return 0;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private int SafeStringLength(string value)
		{
			return value?.Length ?? 0;
		}

		private bool CheckEmptySequence()
		{
			return CheckEmptyStructure<SequenceStart, SequenceEnd>();
		}

		private bool CheckEmptyMapping()
		{
			return CheckEmptyStructure<MappingStart, MappingEnd>();
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)]
		private bool CheckEmptyStructure<TStart, TEnd>() where TStart : NodeEvent where TEnd : ParsingEvent
		{
			if (events.Count < 2)
			{
				return false;
			}
			using Queue<ParsingEvent>.Enumerator enumerator = events.GetEnumerator();
			return enumerator.MoveNext() && enumerator.Current is TStart && enumerator.MoveNext() && enumerator.Current is TEnd;
		}

		private void WriteBlockScalarHints(string value)
		{
			CharacterAnalyzer<StringLookAheadBuffer> characterAnalyzer = new CharacterAnalyzer<StringLookAheadBuffer>(new StringLookAheadBuffer(value));
			if (characterAnalyzer.IsSpace() || characterAnalyzer.IsBreak())
			{
				int num = bestIndent;
				string indicator = num.ToString(CultureInfo.InvariantCulture);
				WriteIndicator(indicator, needWhitespace: false, whitespace: false, indentation: false);
			}
			string text = null;
			if (value.Length == 0 || !characterAnalyzer.IsBreak(value.Length - 1))
			{
				text = "-";
			}
			else if (value.Length >= 2 && characterAnalyzer.IsBreak(value.Length - 2))
			{
				text = "+";
			}
			if (text != null)
			{
				WriteIndicator(text, needWhitespace: false, whitespace: false, indentation: false);
			}
		}

		private void WriteIndicator(string indicator, bool needWhitespace, bool whitespace, bool indentation)
		{
			if (needWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(indicator);
			isWhitespace = whitespace;
			isIndentation &= indentation;
		}

		private void WriteIndent()
		{
			int num = Math.Max(indent, 0);
			if (!isIndentation || column > num || (column == num && !isWhitespace))
			{
				WriteBreak();
			}
			while (column < num)
			{
				Write(' ');
			}
			isWhitespace = true;
			isIndentation = true;
		}

		private void WriteAnchor(AnchorName value)
		{
			Write(value.Value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagHandle(string value)
		{
			if (!isWhitespace)
			{
				Write(' ');
			}
			Write(value);
			isWhitespace = false;
			isIndentation = false;
		}

		private void WriteTagContent(string value, bool needsWhitespace)
		{
			if (needsWhitespace && !isWhitespace)
			{
				Write(' ');
			}
			Write(UrlEncode(value));
			isWhitespace = false;
			isIndentation = false;
		}

		private static string UrlEncode(string text)
		{
			return UriReplacer.Replace(text, [<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] ([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)] Match match) =>
			{
				StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder = builderWrapper.Builder;
					byte[] bytes = Encoding.UTF8.GetBytes(match.Value);
					foreach (byte b in bytes)
					{
						builder.AppendFormat("%{0:X02}", b);
					}
					return builder.ToString();
				}
				finally
				{
					((IDisposable)builderWrapper).Dispose();
				}
			});
		}

		private void Write(char value)
		{
			output.Write(value);
			column++;
		}

		private void Write(string value)
		{
			output.Write(value);
			column += value.Length;
		}

		private void WriteBreak(char breakCharacter = '\n')
		{
			if (breakCharacter == '\n')
			{
				output.Write(newLine);
			}
			else
			{
				output.Write(breakCharacter);
			}
			column = 0;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class EmitterSettings
	{
		public static readonly EmitterSettings Default = new EmitterSettings();

		public int BestIndent { get; } = 2;


		public int BestWidth { get; } = int.MaxValue;


		public string NewLine { get; } = Environment.NewLine;


		public bool IsCanonical { get; }

		public bool SkipAnchorName { get; private set; }

		public int MaxSimpleKeyLength { get; } = 1024;


		public bool IndentSequences { get; }

		public EmitterSettings()
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public EmitterSettings(int bestIndent, int bestWidth, bool isCanonical, int maxSimpleKeyLength, bool skipAnchorName = false, bool indentSequences = false, string newLine = null)
		{
			if (bestIndent < 2 || bestIndent > 9)
			{
				throw new ArgumentOutOfRangeException("bestIndent", "BestIndent must be between 2 and 9, inclusive");
			}
			if (bestWidth <= bestIndent * 2)
			{
				throw new ArgumentOutOfRangeException("bestWidth", "BestWidth must be greater than BestIndent x 2.");
			}
			if (maxSimpleKeyLength < 0)
			{
				throw new ArgumentOutOfRangeException("maxSimpleKeyLength", "MaxSimpleKeyLength must be >= 0");
			}
			BestIndent = bestIndent;
			BestWidth = bestWidth;
			IsCanonical = isCanonical;
			MaxSimpleKeyLength = maxSimpleKeyLength;
			SkipAnchorName = skipAnchorName;
			IndentSequences = indentSequences;
			NewLine = newLine ?? Environment.NewLine;
		}

		public EmitterSettings WithBestIndent(int bestIndent)
		{
			return new EmitterSettings(bestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
		}

		public EmitterSettings WithBestWidth(int bestWidth)
		{
			return new EmitterSettings(BestIndent, bestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
		}

		public EmitterSettings WithMaxSimpleKeyLength(int maxSimpleKeyLength)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, maxSimpleKeyLength, SkipAnchorName, IndentSequences, NewLine);
		}

		public EmitterSettings WithNewLine(string newLine)
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, IndentSequences, newLine);
		}

		public EmitterSettings Canonical()
		{
			return new EmitterSettings(BestIndent, BestWidth, isCanonical: true, MaxSimpleKeyLength, SkipAnchorName);
		}

		public EmitterSettings WithoutAnchorName()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, skipAnchorName: true, IndentSequences, NewLine);
		}

		public EmitterSettings WithIndentedSequences()
		{
			return new EmitterSettings(BestIndent, BestWidth, IsCanonical, MaxSimpleKeyLength, SkipAnchorName, indentSequences: true, NewLine);
		}
	}
	internal enum EmitterState
	{
		StreamStart,
		StreamEnd,
		FirstDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		FlowSequenceFirstItem,
		FlowSequenceItem,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingSimpleValue,
		FlowMappingValue,
		BlockSequenceFirstItem,
		BlockSequenceItem,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingSimpleValue,
		BlockMappingValue
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class ForwardAnchorNotSupportedException : YamlException
	{
		public ForwardAnchorNotSupportedException(string message)
			: base(message)
		{
		}

		public ForwardAnchorNotSupportedException([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end, string message)
			: base(ref start, ref end, message)
		{
		}

		public ForwardAnchorNotSupportedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal static class HashCode
	{
		public static int CombineHashCodes(int h1, int h2)
		{
			return ((h1 << 5) + h1) ^ h2;
		}

		public static int CombineHashCodes(int h1, object o2)
		{
			return CombineHashCodes(h1, GetHashCode(o2));
		}

		private static int GetHashCode(object obj)
		{
			return obj?.GetHashCode() ?? 0;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IEmitter
	{
		void Emit(ParsingEvent @event);
	}
	internal interface ILookAheadBuffer
	{
		bool EndOfInput { get; }

		char Peek(int offset);

		void Skip(int length);
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class InsertionQueue<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] T> : IEnumerable<T>, IEnumerable
	{
		private const int DefaultInitialCapacity = 128;

		private T[] items;

		private int readPtr;

		private int writePtr;

		private int mask;

		private int count;

		public int Count => count;

		public int Capacity => items.Length;

		public InsertionQueue(int initialCapacity = 128)
		{
			if (initialCapacity <= 0)
			{
				throw new ArgumentOutOfRangeException("initialCapacity", "The initial capacity must be a positive number.");
			}
			if (!initialCapacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The initial capacity must be a power of 2.", "initialCapacity");
			}
			items = new T[initialCapacity];
			readPtr = initialCapacity / 2;
			writePtr = initialCapacity / 2;
			mask = initialCapacity - 1;
		}

		public void Enqueue(T item)
		{
			ResizeIfNeeded();
			items[writePtr] = item;
			writePtr = (writePtr - 1) & mask;
			count++;
		}

		public T Dequeue()
		{
			if (count == 0)
			{
				throw new InvalidOperationException("The queue is empty");
			}
			T result = items[readPtr];
			readPtr = (readPtr - 1) & mask;
			count--;
			return result;
		}

		public void Insert(int index, T item)
		{
			if (index > count)
			{
				throw new InvalidOperationException("Cannot insert outside of the bounds of the queue");
			}
			ResizeIfNeeded();
			CalculateInsertionParameters(mask, count, index, ref readPtr, ref writePtr, out var insertPtr, out var copyIndex, out var copyOffset, out var copyLength);
			if (copyLength != 0)
			{
				Array.Copy(items, copyIndex, items, copyIndex + copyOffset, copyLength);
			}
			items[insertPtr] = item;
			count++;
		}

		private void ResizeIfNeeded()
		{
			int num = items.Length;
			if (count == num)
			{
				T[] destinationArray = new T[num * 2];
				int num2 = readPtr + 1;
				if (num2 > 0)
				{
					Array.Copy(items, 0, destinationArray, 0, num2);
				}
				writePtr += num;
				int num3 = num - num2;
				if (num3 > 0)
				{
					Array.Copy(items, readPtr + 1, destinationArray, writePtr + 1, num3);
				}
				items = destinationArray;
				mask = mask * 2 + 1;
			}
		}

		internal static void CalculateInsertionParameters(int mask, int count, int index, ref int readPtr, ref int writePtr, out int insertPtr, out int copyIndex, out int copyOffset, out int copyLength)
		{
			int num = (readPtr + 1) & mask;
			if (index == 0)
			{
				insertPtr = (readPtr = num);
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			insertPtr = (readPtr - index) & mask;
			if (index == count)
			{
				writePtr = (writePtr - 1) & mask;
				copyIndex = 0;
				copyOffset = 0;
				copyLength = 0;
				return;
			}
			int num2 = ((num >= insertPtr) ? (readPtr - insertPtr) : int.MaxValue);
			int num3 = ((writePtr <= insertPtr) ? (insertPtr - writePtr) : int.MaxValue);
			if (num2 <= num3)
			{
				insertPtr++;
				readPtr++;
				copyIndex = insertPtr;
				copyOffset = 1;
				copyLength = num2;
			}
			else
			{
				copyIndex = writePtr + 1;
				copyOffset = -1;
				copyLength = num3;
				writePtr = (writePtr - 1) & mask;
			}
		}

		public IEnumerator<T> GetEnumerator()
		{
			int ptr = readPtr;
			for (int i = 0; i < Count; i++)
			{
				yield return items[ptr];
				ptr = (ptr - 1) & mask;
			}
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	internal interface IParser
	{
		ParsingEvent Current { get; }

		bool MoveNext();
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	internal interface IScanner
	{
		Mark CurrentPosition { get; }

		Token Current { get; }

		bool MoveNext();

		bool MoveNextWithoutConsuming();

		void ConsumeCurrent();
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[DebuggerStepThrough]
	internal sealed class LookAheadBuffer : ILookAheadBuffer
	{
		private readonly TextReader input;

		private readonly char[] buffer;

		private readonly int blockSize;

		private readonly int mask;

		private int firstIndex;

		private int writeOffset;

		private int count;

		private bool endOfInput;

		public bool EndOfInput
		{
			get
			{
				if (endOfInput)
				{
					return count == 0;
				}
				return false;
			}
		}

		public LookAheadBuffer(TextReader input, int capacity)
		{
			if (capacity < 1)
			{
				throw new ArgumentOutOfRangeException("capacity", "The capacity must be positive.");
			}
			if (!capacity.IsPowerOfTwo())
			{
				throw new ArgumentException("The capacity must be a power of 2.", "capacity");
			}
			this.input = input ?? throw new ArgumentNullException("input");
			blockSize = capacity;
			buffer = new char[capacity * 2];
			mask = capacity * 2 - 1;
		}

		private int GetIndexForOffset(int offset)
		{
			return (firstIndex + offset) & mask;
		}

		public char Peek(int offset)
		{
			if (offset >= count)
			{
				FillBuffer();
			}
			if (offset < count)
			{
				return buffer[(firstIndex + offset) & mask];
			}
			return '\0';
		}

		public void Cache(int length)
		{
			if (length >= count)
			{
				FillBuffer();
			}
		}

		private void FillBuffer()
		{
			if (endOfInput)
			{
				return;
			}
			int num = blockSize;
			do
			{
				int num2 = input.Read(buffer, writeOffset, num);
				if (num2 == 0)
				{
					endOfInput = true;
					return;
				}
				num -= num2;
				writeOffset += num2;
				count += num2;
			}
			while (num > 0);
			if (writeOffset == buffer.Length)
			{
				writeOffset = 0;
			}
		}

		public void Skip(int length)
		{
			if (length < 1 || length > blockSize)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be between 1 and the number of characters in the buffer. Use the Peek() and / or Cache() methods to fill the buffer.");
			}
			firstIndex = GetIndexForOffset(length);
			count -= length;
		}
	}
	[<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly]
	internal struct Mark : IEquatable<Mark>, IComparable<Mark>, IComparable
	{
		public static readonly Mark Empty = new Mark(0, 1, 1);

		public int Index { get; }

		public int Line { get; }

		public int Column { get; }

		public Mark(int index, int line, int column)
		{
			if (index < 0)
			{
				YamlDotNet.Helpers.ThrowHelper.ThrowArgumentOutOfRangeException("index", "Index must be greater than or equal to zero.");
			}
			if (line < 1)
			{
				YamlDotNet.Helpers.ThrowHelper.ThrowArgumentOutOfRangeException("line", "Line must be greater than or equal to 1.");
			}
			if (column < 1)
			{
				YamlDotNet.Helpers.ThrowHelper.ThrowArgumentOutOfRangeException("column", "Column must be greater than or equal to 1.");
			}
			Index = index;
			Line = line;
			Column = column;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public override string ToString()
		{
			return $"Line: {Line}, Col: {Column}, Idx: {Index}";
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			return Equals((Mark)(obj ?? ((object)Empty)));
		}

		public bool Equals(Mark other)
		{
			if (Index == other.Index && Line == other.Line)
			{
				return Column == other.Column;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Index.GetHashCode(), HashCode.CombineHashCodes(Line.GetHashCode(), Column.GetHashCode()));
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public int CompareTo(object obj)
		{
			return CompareTo((Mark)(obj ?? ((object)Empty)));
		}

		public int CompareTo(Mark other)
		{
			int num = Line.CompareTo(other.Line);
			if (num == 0)
			{
				num = Column.CompareTo(other.Column);
			}
			return num;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class MaximumRecursionLevelReachedException : YamlException
	{
		public MaximumRecursionLevelReachedException(string message)
			: base(message)
		{
		}

		public MaximumRecursionLevelReachedException([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end, string message)
			: base(ref start, ref end, message)
		{
		}

		public MaximumRecursionLevelReachedException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class MergingParser : IParser
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private sealed class ParsingEventCollection : IEnumerable<LinkedListNode<ParsingEvent>>, IEnumerable
		{
			private readonly LinkedList<ParsingEvent> events;

			private readonly HashSet<LinkedListNode<ParsingEvent>> deleted;

			private readonly Dictionary<AnchorName, LinkedListNode<ParsingEvent>> references;

			public ParsingEventCollection()
			{
				events = new LinkedList<ParsingEvent>();
				deleted = new HashSet<LinkedListNode<ParsingEvent>>();
				references = new Dictionary<AnchorName, LinkedListNode<ParsingEvent>>();
			}

			public void AddAfter(LinkedListNode<ParsingEvent> node, IEnumerable<ParsingEvent> items)
			{
				foreach (ParsingEvent item in items)
				{
					node = events.AddAfter(node, item);
				}
			}

			public void Add(ParsingEvent item)
			{
				LinkedListNode<ParsingEvent> node = events.AddLast(item);
				AddReference(item, node);
			}

			public void MarkDeleted(LinkedListNode<ParsingEvent> node)
			{
				deleted.Add(node);
			}

			public bool IsDeleted(LinkedListNode<ParsingEvent> node)
			{
				return deleted.Contains(node);
			}

			public void CleanMarked()
			{
				foreach (LinkedListNode<ParsingEvent> item in deleted)
				{
					events.Remove(item);
				}
			}

			public IEnumerable<LinkedListNode<ParsingEvent>> FromAnchor(AnchorName anchor)
			{
				LinkedListNode<ParsingEvent> next = references[anchor].Next;
				return Enumerate(next);
			}

			public IEnumerator<LinkedListNode<ParsingEvent>> GetEnumerator()
			{
				return Enumerate(events.First).GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private IEnumerable<LinkedListNode<ParsingEvent>> Enumerate([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })] LinkedListNode<ParsingEvent> node)
			{
				while (node != null)
				{
					yield return node;
					node = node.Next;
				}
			}

			private void AddReference(ParsingEvent item, LinkedListNode<ParsingEvent> node)
			{
				if (item is MappingStart mappingStart)
				{
					AnchorName anchor = mappingStart.Anchor;
					if (!anchor.IsEmpty)
					{
						references[anchor] = node;
					}
				}
			}
		}

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private sealed class ParsingEventCloner : IParsingEventVisitor
		{
			[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
			private ParsingEvent clonedEvent;

			public ParsingEvent Clone(ParsingEvent e)
			{
				e.Accept(this);
				if (clonedEvent == null)
				{
					throw new InvalidOperationException($"Could not clone event of type '{e.Type}'");
				}
				return clonedEvent;
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.AnchorAlias e)
			{
				clonedEvent = new YamlDotNet.Core.Events.AnchorAlias(e.Value, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.StreamEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentStart e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.DocumentEnd e)
			{
				throw new NotSupportedException();
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Scalar e)
			{
				clonedEvent = new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, e.Tag, e.Value, e.Style, e.IsPlainImplicit, e.IsQuotedImplicit, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceStart e)
			{
				clonedEvent = new SequenceStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(SequenceEnd e)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new SequenceEnd(ref start, ref end);
			}

			void IParsingEventVisitor.Visit(MappingStart e)
			{
				clonedEvent = new MappingStart(AnchorName.Empty, e.Tag, e.IsImplicit, e.Style, e.Start, e.End);
			}

			void IParsingEventVisitor.Visit(MappingEnd e)
			{
				Mark start = e.Start;
				Mark end = e.End;
				clonedEvent = new MappingEnd(ref start, ref end);
			}

			void IParsingEventVisitor.Visit(YamlDotNet.Core.Events.Comment e)
			{
				throw new NotSupportedException();
			}
		}

		private readonly ParsingEventCollection events;

		private readonly IParser innerParser;

		private IEnumerator<LinkedListNode<ParsingEvent>> iterator;

		private bool merged;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public ParsingEvent Current
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get
			{
				return iterator.Current?.Value;
			}
		}

		public MergingParser(IParser innerParser)
		{
			events = new ParsingEventCollection();
			merged = false;
			iterator = events.GetEnumerator();
			this.innerParser = innerParser;
		}

		public bool MoveNext()
		{
			if (!merged)
			{
				Merge();
				events.CleanMarked();
				iterator = events.GetEnumerator();
				merged = true;
			}
			return iterator.MoveNext();
		}

		private void Merge()
		{
			while (innerParser.MoveNext())
			{
				events.Add(innerParser.Current);
			}
			foreach (LinkedListNode<ParsingEvent> @event in events)
			{
				if (IsMergeToken(@event))
				{
					events.MarkDeleted(@event);
					if (!HandleMerge(@event.Next))
					{
						Mark start = @event.Value.Start;
						Mark end = @event.Value.End;
						throw new SemanticErrorException(ref start, ref end, "Unrecognized merge key pattern");
					}
				}
			}
		}

		private bool HandleMerge([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })] LinkedListNode<ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(node, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool HandleMergeSequence(LinkedListNode<ParsingEvent> sequenceStart, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 2, 1 })] LinkedListNode<ParsingEvent> node)
		{
			if (node == null)
			{
				return false;
			}
			if (node.Value is YamlDotNet.Core.Events.AnchorAlias anchorAlias)
			{
				return HandleAnchorAlias(sequenceStart, node, anchorAlias);
			}
			if (node.Value is SequenceStart)
			{
				return HandleSequence(node);
			}
			return false;
		}

		private bool IsMergeToken(LinkedListNode<ParsingEvent> node)
		{
			if (node.Value is YamlDotNet.Core.Events.Scalar scalar)
			{
				return scalar.Value == "<<";
			}
			return false;
		}

		private bool HandleAnchorAlias(LinkedListNode<ParsingEvent> node, LinkedListNode<ParsingEvent> anchorNode, YamlDotNet.Core.Events.AnchorAlias anchorAlias)
		{
			IEnumerable<ParsingEvent> mappingEvents = GetMappingEvents(anchorAlias.Value);
			events.AddAfter(node, mappingEvents);
			events.MarkDeleted(anchorNode);
			return true;
		}

		private bool HandleSequence(LinkedListNode<ParsingEvent> node)
		{
			events.MarkDeleted(node);
			LinkedListNode<ParsingEvent> linkedListNode = node;
			while (linkedListNode != null)
			{
				if (linkedListNode.Value is SequenceEnd)
				{
					events.MarkDeleted(linkedListNode);
					return true;
				}
				LinkedListNode<ParsingEvent> next = linkedListNode.Next;
				HandleMergeSequence(node, next);
				linkedListNode = next;
			}
			return true;
		}

		private IEnumerable<ParsingEvent> GetMappingEvents(AnchorName anchor)
		{
			ParsingEventCloner cloner = new ParsingEventCloner();
			int nesting = 0;
			return from e in (from e in events.FromAnchor(anchor)
					where !events.IsDeleted(e)
					select e.Value).TakeWhile([<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(0)] (ParsingEvent e) => (nesting += e.NestingIncrease) >= 0)
				select cloner.Clone(e);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class Parser : IParser
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
		private class EventQueue
		{
			private readonly Queue<ParsingEvent> highPriorityEvents = new Queue<ParsingEvent>();

			private readonly Queue<ParsingEvent> normalPriorityEvents = new Queue<ParsingEvent>();

			public int Count => highPriorityEvents.Count + normalPriorityEvents.Count;

			public void Enqueue(ParsingEvent @event)
			{
				EventType type = @event.Type;
				if (type == EventType.StreamStart || type == EventType.DocumentStart)
				{
					highPriorityEvents.Enqueue(@event);
				}
				else
				{
					normalPriorityEvents.Enqueue(@event);
				}
			}

			public ParsingEvent Dequeue()
			{
				if (highPriorityEvents.Count <= 0)
				{
					return normalPriorityEvents.Dequeue();
				}
				return highPriorityEvents.Dequeue();
			}
		}

		private readonly Stack<ParserState> states = new Stack<ParserState>();

		private readonly TagDirectiveCollection tagDirectives = new TagDirectiveCollection();

		private ParserState state;

		private readonly IScanner scanner;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private Token currentToken;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private VersionDirective version;

		private readonly EventQueue pendingEvents = new EventQueue();

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		[field: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public ParsingEvent Current
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get;
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			private set;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private Token GetCurrentToken()
		{
			if (currentToken == null)
			{
				while (scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (!(currentToken is YamlDotNet.Core.Tokens.Comment comment))
					{
						break;
					}
					pendingEvents.Enqueue(new YamlDotNet.Core.Events.Comment(comment.Value, comment.IsInline, comment.Start, comment.End));
					scanner.ConsumeCurrent();
				}
			}
			return currentToken;
		}

		public Parser(TextReader input)
			: this(new Scanner(input))
		{
		}

		public Parser(IScanner scanner)
		{
			this.scanner = scanner;
		}

		public bool MoveNext()
		{
			if (state == ParserState.StreamEnd)
			{
				Current = null;
				return false;
			}
			if (pendingEvents.Count == 0)
			{
				pendingEvents.Enqueue(StateMachine());
			}
			Current = pendingEvents.Dequeue();
			return true;
		}

		private ParsingEvent StateMachine()
		{
			return state switch
			{
				ParserState.StreamStart => ParseStreamStart(), 
				ParserState.ImplicitDocumentStart => ParseDocumentStart(isImplicit: true), 
				ParserState.DocumentStart => ParseDocumentStart(isImplicit: false), 
				ParserState.DocumentContent => ParseDocumentContent(), 
				ParserState.DocumentEnd => ParseDocumentEnd(), 
				ParserState.BlockNode => ParseNode(isBlock: true, isIndentlessSequence: false), 
				ParserState.BlockNodeOrIndentlessSequence => ParseNode(isBlock: true, isIndentlessSequence: true), 
				ParserState.FlowNode => ParseNode(isBlock: false, isIndentlessSequence: false), 
				ParserState.BlockSequenceFirstEntry => ParseBlockSequenceEntry(isFirst: true), 
				ParserState.BlockSequenceEntry => ParseBlockSequenceEntry(isFirst: false), 
				ParserState.IndentlessSequenceEntry => ParseIndentlessSequenceEntry(), 
				ParserState.BlockMappingFirstKey => ParseBlockMappingKey(isFirst: true), 
				ParserState.BlockMappingKey => ParseBlockMappingKey(isFirst: false), 
				ParserState.BlockMappingValue => ParseBlockMappingValue(), 
				ParserState.FlowSequenceFirstEntry => ParseFlowSequenceEntry(isFirst: true), 
				ParserState.FlowSequenceEntry => ParseFlowSequenceEntry(isFirst: false), 
				ParserState.FlowSequenceEntryMappingKey => ParseFlowSequenceEntryMappingKey(), 
				ParserState.FlowSequenceEntryMappingValue => ParseFlowSequenceEntryMappingValue(), 
				ParserState.FlowSequenceEntryMappingEnd => ParseFlowSequenceEntryMappingEnd(), 
				ParserState.FlowMappingFirstKey => ParseFlowMappingKey(isFirst: true), 
				ParserState.FlowMappingKey => ParseFlowMappingKey(isFirst: false), 
				ParserState.FlowMappingValue => ParseFlowMappingValue(isEmpty: false), 
				ParserState.FlowMappingEmptyValue => ParseFlowMappingValue(isEmpty: true), 
				_ => throw new InvalidOperationException(), 
			};
		}

		private void Skip()
		{
			if (currentToken != null)
			{
				currentToken = null;
				scanner.ConsumeCurrent();
			}
		}

		private ParsingEvent ParseStreamStart()
		{
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is YamlDotNet.Core.Tokens.StreamStart streamStart))
			{
				start = token?.Start ?? Mark.Empty;
				end = token?.End ?? Mark.Empty;
				throw new SemanticErrorException(ref start, ref end, "Did not find expected <stream-start>.");
			}
			Skip();
			state = ParserState.ImplicitDocumentStart;
			start = streamStart.Start;
			end = streamStart.End;
			return new YamlDotNet.Core.Events.StreamStart(ref start, ref end);
		}

		private ParsingEvent ParseDocumentStart(bool isImplicit)
		{
			if (currentToken is VersionDirective)
			{
				throw new SyntaxErrorException("While parsing a document start node, could not find document end marker before version directive.");
			}
			Token token = GetCurrentToken();
			if (!isImplicit)
			{
				while (token is YamlDotNet.Core.Tokens.DocumentEnd)
				{
					Skip();
					token = GetCurrentToken();
				}
			}
			if (token == null)
			{
				throw new SyntaxErrorException("Reached the end of the stream while parsing a document start.");
			}
			if (token is YamlDotNet.Core.Tokens.Scalar && (state == ParserState.ImplicitDocumentStart || state == ParserState.DocumentStart))
			{
				isImplicit = true;
			}
			if ((isImplicit && !(token is VersionDirective) && !(token is TagDirective) && !(token is YamlDotNet.Core.Tokens.DocumentStart) && !(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd)) || token is BlockMappingStart)
			{
				TagDirectiveCollection tags = new TagDirectiveCollection();
				ProcessDirectives(tags);
				states.Push(ParserState.DocumentEnd);
				state = ParserState.BlockNode;
				return new YamlDotNet.Core.Events.DocumentStart(null, tags, isImplicit: true, token.Start, token.End);
			}
			Mark start2;
			Mark end;
			if (!(token is YamlDotNet.Core.Tokens.StreamEnd) && !(token is YamlDotNet.Core.Tokens.DocumentEnd))
			{
				Mark start = token.Start;
				TagDirectiveCollection tags2 = new TagDirectiveCollection();
				VersionDirective versionDirective = ProcessDirectives(tags2);
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
				if (!(token is YamlDotNet.Core.Tokens.DocumentStart))
				{
					start2 = token.Start;
					end = token.End;
					throw new SemanticErrorException(ref start2, ref end, "Did not find expected <document start>.");
				}
				states.Push(ParserState.DocumentEnd);
				state = ParserState.DocumentContent;
				Mark end2 = token.End;
				Skip();
				return new YamlDotNet.Core.Events.DocumentStart(versionDirective, tags2, isImplicit: false, start, end2);
			}
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				Skip();
			}
			state = ParserState.StreamEnd;
			token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document start");
			start2 = token.Start;
			end = token.End;
			YamlDotNet.Core.Events.StreamEnd result = new YamlDotNet.Core.Events.StreamEnd(ref start2, ref end);
			if (scanner.MoveNextWithoutConsuming())
			{
				throw new InvalidOperationException("The scanner should contain no more tokens.");
			}
			return result;
		}

		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private VersionDirective ProcessDirectives(TagDirectiveCollection tags)
		{
			bool flag = false;
			VersionDirective result = null;
			while (true)
			{
				if (GetCurrentToken() is VersionDirective versionDirective)
				{
					if (version != null)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(ref start, ref end, "Found duplicate %YAML directive.");
					}
					if (versionDirective.Version.Major != 1 || versionDirective.Version.Minor > 3)
					{
						Mark start = versionDirective.Start;
						Mark end = versionDirective.End;
						throw new SemanticErrorException(ref start, ref end, "Found incompatible YAML document.");
					}
					result = (version = versionDirective);
					flag = true;
				}
				else
				{
					if (!(GetCurrentToken() is TagDirective tagDirective))
					{
						break;
					}
					if (tags.Contains(tagDirective.Handle))
					{
						Mark start = tagDirective.Start;
						Mark end = tagDirective.End;
						throw new SemanticErrorException(ref start, ref end, "Found duplicate %TAG directive.");
					}
					tags.Add(tagDirective);
					flag = true;
				}
				Skip();
			}
			if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && (version == null || (version.Version.Major == 1 && version.Version.Minor > 1)))
			{
				if (GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart && version == null)
				{
					version = new VersionDirective(new Version(1, 2));
				}
				flag = true;
			}
			AddTagDirectives(tags, Constants.DefaultTagDirectives);
			if (flag)
			{
				tagDirectives.Clear();
			}
			AddTagDirectives(tagDirectives, tags);
			return result;
		}

		private static void AddTagDirectives(TagDirectiveCollection directives, IEnumerable<TagDirective> source)
		{
			foreach (TagDirective item in source)
			{
				if (!directives.Contains(item))
				{
					directives.Add(item);
				}
			}
		}

		private ParsingEvent ParseDocumentContent()
		{
			if (GetCurrentToken() is VersionDirective || GetCurrentToken() is TagDirective || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentStart || GetCurrentToken() is YamlDotNet.Core.Tokens.DocumentEnd || GetCurrentToken() is YamlDotNet.Core.Tokens.StreamEnd)
			{
				state = states.Pop();
				Mark position = scanner.CurrentPosition;
				return ProcessEmptyScalar(ref position);
			}
			return ParseNode(isBlock: true, isIndentlessSequence: false);
		}

		private static ParsingEvent ProcessEmptyScalar([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark position)
		{
			return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, string.Empty, ScalarStyle.Plain, isPlainImplicit: true, isQuotedImplicit: false, position, position);
		}

		private ParsingEvent ParseNode(bool isBlock, bool isIndentlessSequence)
		{
			Mark start;
			Mark end;
			if (GetCurrentToken() is Error error)
			{
				start = error.Start;
				end = error.End;
				throw new SemanticErrorException(ref start, ref end, error.Value);
			}
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				state = states.Pop();
				YamlDotNet.Core.Events.AnchorAlias result = new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
				Skip();
				return result;
			}
			Mark start2 = token.Start;
			AnchorName anchor = AnchorName.Empty;
			TagName tag = TagName.Empty;
			Anchor anchor2 = null;
			Tag tag2 = null;
			while (true)
			{
				if (anchor.IsEmpty && token is Anchor anchor3)
				{
					anchor2 = anchor3;
					anchor = anchor3.Value;
					Skip();
				}
				else
				{
					if (!tag.IsEmpty || !(token is Tag tag3))
					{
						if (token is Anchor anchor4)
						{
							start = anchor4.Start;
							end = anchor4.End;
							throw new SemanticErrorException(ref start, ref end, "While parsing a node, found more than one anchor.");
						}
						if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias2)
						{
							start = anchorAlias2.Start;
							end = anchorAlias2.End;
							throw new SemanticErrorException(ref start, ref end, "While parsing a node, did not find expected token.");
						}
						if (!(token is Error error2))
						{
							break;
						}
						if (tag2 != null && anchor2 != null && !anchor.IsEmpty)
						{
							return new YamlDotNet.Core.Events.Scalar(anchor, default(TagName), string.Empty, ScalarStyle.Any, isPlainImplicit: false, isQuotedImplicit: false, anchor2.Start, anchor2.End);
						}
						start = error2.Start;
						end = error2.End;
						throw new SemanticErrorException(ref start, ref end, error2.Value);
					}
					tag2 = tag3;
					if (string.IsNullOrEmpty(tag3.Handle))
					{
						tag = new TagName(tag3.Suffix);
					}
					else
					{
						if (!tagDirectives.Contains(tag3.Handle))
						{
							start = tag3.Start;
							end = tag3.End;
							throw new SemanticErrorException(ref start, ref end, "While parsing a node, found undefined tag handle.");
						}
						tag = new TagName(tagDirectives[tag3.Handle].Prefix + tag3.Suffix);
					}
					Skip();
				}
				token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a node");
			}
			bool isEmpty = tag.IsEmpty;
			if (isIndentlessSequence && GetCurrentToken() is BlockEntry)
			{
				state = ParserState.IndentlessSequenceEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, token.End);
			}
			if (token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				bool isPlainImplicit = false;
				bool isQuotedImplicit = false;
				if ((scalar.Style == ScalarStyle.Plain && tag.IsEmpty) || tag.IsNonSpecific)
				{
					isPlainImplicit = true;
				}
				else if (tag.IsEmpty)
				{
					isQuotedImplicit = true;
				}
				state = states.Pop();
				Skip();
				YamlDotNet.Core.Events.Scalar result2 = new YamlDotNet.Core.Events.Scalar(anchor, tag, scalar.Value, scalar.Style, isPlainImplicit, isQuotedImplicit, start2, scalar.End, scalar.IsKey);
				if (!anchor.IsEmpty && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken is Error)
					{
						Error error3 = currentToken as Error;
						start = error3.Start;
						end = error3.End;
						throw new SemanticErrorException(ref start, ref end, error3.Value);
					}
				}
				if (state == ParserState.FlowMappingKey && scanner.MoveNextWithoutConsuming())
				{
					currentToken = scanner.Current;
					if (currentToken != null && !(currentToken is FlowEntry) && !(currentToken is FlowMappingEnd))
					{
						start = currentToken.Start;
						end = currentToken.End;
						throw new SemanticErrorException(ref start, ref end, "While parsing a flow mapping, did not find expected ',' or '}'.");
					}
				}
				return result2;
			}
			if (token is FlowSequenceStart flowSequenceStart)
			{
				state = ParserState.FlowSequenceFirstEntry;
				return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Flow, start2, flowSequenceStart.End);
			}
			if (token is FlowMappingStart flowMappingStart)
			{
				state = ParserState.FlowMappingFirstKey;
				return new MappingStart(anchor, tag, isEmpty, MappingStyle.Flow, start2, flowMappingStart.End);
			}
			if (isBlock)
			{
				if (token is BlockSequenceStart blockSequenceStart)
				{
					state = ParserState.BlockSequenceFirstEntry;
					return new SequenceStart(anchor, tag, isEmpty, SequenceStyle.Block, start2, blockSequenceStart.End);
				}
				if (token is BlockMappingStart blockMappingStart)
				{
					state = ParserState.BlockMappingFirstKey;
					return new MappingStart(anchor, tag, isEmpty, MappingStyle.Block, start2, blockMappingStart.End);
				}
			}
			if (!anchor.IsEmpty || !tag.IsEmpty)
			{
				state = states.Pop();
				return new YamlDotNet.Core.Events.Scalar(anchor, tag, string.Empty, ScalarStyle.Plain, isEmpty, isQuotedImplicit: false, start2, token.End);
			}
			start = token.Start;
			end = token.End;
			throw new SemanticErrorException(ref start, ref end, "While parsing a node, did not find expected node content.");
		}

		private ParsingEvent ParseDocumentEnd()
		{
			Token token = GetCurrentToken() ?? throw new SemanticErrorException("Reached the end of the stream while parsing a document end");
			bool isImplicit = true;
			Mark start = token.Start;
			Mark end = start;
			if (token is YamlDotNet.Core.Tokens.DocumentEnd)
			{
				end = token.End;
				Skip();
				isImplicit = false;
			}
			else if (!(currentToken is YamlDotNet.Core.Tokens.StreamEnd) && !(currentToken is YamlDotNet.Core.Tokens.DocumentStart) && !(currentToken is FlowSequenceEnd) && !(currentToken is VersionDirective) && (!(Current is YamlDotNet.Core.Events.Scalar) || !(currentToken is Error)))
			{
				throw new SemanticErrorException(ref start, ref end, "Did not find expected <document end>.");
			}
			if (version != null && version.Version.Major == 1 && version.Version.Minor > 1)
			{
				version = null;
			}
			state = ParserState.DocumentStart;
			return new YamlDotNet.Core.Events.DocumentEnd(isImplicit, start, end);
		}

		private ParsingEvent ParseBlockSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is BlockEntry blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.BlockSequenceEntry;
				return ProcessEmptyScalar(ref position);
			}
			Mark start;
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				start = blockEnd.Start;
				end = blockEnd.End;
				SequenceEnd result = new SequenceEnd(ref start, ref end);
				Skip();
				return result;
			}
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(ref start, ref end, "While parsing a block collection, did not find expected '-' indicator.");
		}

		private ParsingEvent ParseIndentlessSequenceEntry()
		{
			Token token = GetCurrentToken();
			if (token is BlockEntry blockEntry)
			{
				Mark position = blockEntry.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is BlockEntry) && !(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.IndentlessSequenceEntry);
					return ParseNode(isBlock: true, isIndentlessSequence: false);
				}
				state = ParserState.IndentlessSequenceEntry;
				return ProcessEmptyScalar(ref position);
			}
			state = states.Pop();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new SequenceEnd(ref start, ref end);
		}

		private ParsingEvent ParseBlockMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			if (token is Key key)
			{
				Mark position = key.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingValue);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingValue;
				return ProcessEmptyScalar(ref position);
			}
			Mark position2;
			if (token is Value value)
			{
				Skip();
				position2 = value.End;
				return ProcessEmptyScalar(ref position2);
			}
			if (token is YamlDotNet.Core.Tokens.AnchorAlias anchorAlias)
			{
				Skip();
				return new YamlDotNet.Core.Events.AnchorAlias(anchorAlias.Value, anchorAlias.Start, anchorAlias.End);
			}
			Mark end;
			if (token is BlockEnd blockEnd)
			{
				state = states.Pop();
				position2 = blockEnd.Start;
				end = blockEnd.End;
				MappingEnd result = new MappingEnd(ref position2, ref end);
				Skip();
				return result;
			}
			if (GetCurrentToken() is Error error)
			{
				position2 = error.Start;
				end = error.End;
				throw new SyntaxErrorException(ref position2, ref end, error.Value);
			}
			position2 = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			throw new SemanticErrorException(ref position2, ref end, "While parsing a block mapping, did not find expected key.");
		}

		private ParsingEvent ParseBlockMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value value)
			{
				Mark position = value.End;
				Skip();
				token = GetCurrentToken();
				if (!(token is Key) && !(token is Value) && !(token is BlockEnd))
				{
					states.Push(ParserState.BlockMappingKey);
					return ParseNode(isBlock: true, isIndentlessSequence: true);
				}
				state = ParserState.BlockMappingKey;
				return ProcessEmptyScalar(ref position);
			}
			Mark start;
			if (token is Error error)
			{
				start = error.Start;
				Mark end = error.End;
				throw new SemanticErrorException(ref start, ref end, error.Value);
			}
			state = ParserState.BlockMappingKey;
			start = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(ref start);
		}

		private ParsingEvent ParseFlowSequenceEntry(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is FlowSequenceEnd))
			{
				if (!isFirst)
				{
					if (!(token is FlowEntry))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(ref start, ref end, "While parsing a flow sequence, did not find expected ',' or ']'.");
					}
					Skip();
					token = GetCurrentToken();
				}
				if (token is Key)
				{
					state = ParserState.FlowSequenceEntryMappingKey;
					MappingStart result = new MappingStart(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Flow);
					Skip();
					return result;
				}
				if (!(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntry);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			SequenceEnd result2 = new SequenceEnd(ref start, ref end);
			Skip();
			return result2;
		}

		private ParsingEvent ParseFlowSequenceEntryMappingKey()
		{
			Token token = GetCurrentToken();
			if (!(token is Value) && !(token is FlowEntry) && !(token is FlowSequenceEnd))
			{
				states.Push(ParserState.FlowSequenceEntryMappingValue);
				return ParseNode(isBlock: false, isIndentlessSequence: false);
			}
			Mark position = token?.End ?? Mark.Empty;
			Skip();
			state = ParserState.FlowSequenceEntryMappingValue;
			return ProcessEmptyScalar(ref position);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingValue()
		{
			Token token = GetCurrentToken();
			if (token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowSequenceEnd))
				{
					states.Push(ParserState.FlowSequenceEntryMappingEnd);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowSequenceEntryMappingEnd;
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(ref position);
		}

		private ParsingEvent ParseFlowSequenceEntryMappingEnd()
		{
			state = ParserState.FlowSequenceEntry;
			Token token = GetCurrentToken();
			Mark start = token?.Start ?? Mark.Empty;
			Mark end = token?.End ?? Mark.Empty;
			return new MappingEnd(ref start, ref end);
		}

		private ParsingEvent ParseFlowMappingKey(bool isFirst)
		{
			if (isFirst)
			{
				GetCurrentToken();
				Skip();
			}
			Token token = GetCurrentToken();
			Mark start;
			Mark end;
			if (!(token is FlowMappingEnd))
			{
				if (!isFirst)
				{
					if (token is FlowEntry)
					{
						Skip();
						token = GetCurrentToken();
					}
					else if (!(token is YamlDotNet.Core.Tokens.Scalar))
					{
						start = token?.Start ?? Mark.Empty;
						end = token?.End ?? Mark.Empty;
						throw new SemanticErrorException(ref start, ref end, "While parsing a flow mapping,  did not find expected ',' or '}'.");
					}
				}
				if (token is Key)
				{
					Skip();
					token = GetCurrentToken();
					if (!(token is Value) && !(token is FlowEntry) && !(token is FlowMappingEnd))
					{
						states.Push(ParserState.FlowMappingValue);
						return ParseNode(isBlock: false, isIndentlessSequence: false);
					}
					state = ParserState.FlowMappingValue;
					start = token?.Start ?? Mark.Empty;
					return ProcessEmptyScalar(ref start);
				}
				if (token is YamlDotNet.Core.Tokens.Scalar)
				{
					states.Push(ParserState.FlowMappingValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
				if (!(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingEmptyValue);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = states.Pop();
			Skip();
			start = token?.Start ?? Mark.Empty;
			end = token?.End ?? Mark.Empty;
			return new MappingEnd(ref start, ref end);
		}

		private ParsingEvent ParseFlowMappingValue(bool isEmpty)
		{
			Token token = GetCurrentToken();
			if (!isEmpty && token is Value)
			{
				Skip();
				token = GetCurrentToken();
				if (!(token is FlowEntry) && !(token is FlowMappingEnd))
				{
					states.Push(ParserState.FlowMappingKey);
					return ParseNode(isBlock: false, isIndentlessSequence: false);
				}
			}
			state = ParserState.FlowMappingKey;
			if (!isEmpty && token is YamlDotNet.Core.Tokens.Scalar scalar)
			{
				Skip();
				return new YamlDotNet.Core.Events.Scalar(AnchorName.Empty, TagName.Empty, scalar.Value, scalar.Style, isPlainImplicit: false, isQuotedImplicit: false, token.Start, scalar.End);
			}
			Mark position = token?.Start ?? Mark.Empty;
			return ProcessEmptyScalar(ref position);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal static class ParserExtensions
	{
		public static T Consume<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			T result = parser.Require<T>();
			parser.MoveNext();
			return result;
		}

		public static bool TryConsume<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Accept<T>(out @event))
			{
				parser.MoveNext();
				return true;
			}
			return false;
		}

		public static T Require<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				ParsingEvent current = parser.Current;
				if (current == null)
				{
					throw new YamlException("Expected '" + typeof(T).Name + "', got nothing.");
				}
				Mark start = current.Start;
				Mark end = current.End;
				throw new YamlException(ref start, ref end, $"Expected '{typeof(T).Name}', got '{current.GetType().Name}' (at {current.Start}).");
			}
			return @event;
		}

		public static bool Accept<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser, [MaybeNullWhen(false)] out T @event) where T : ParsingEvent
		{
			if (parser.Current == null && !parser.MoveNext())
			{
				throw new EndOfStreamException();
			}
			if (parser.Current is T val)
			{
				@event = val;
				return true;
			}
			@event = null;
			return false;
		}

		public static void SkipThisAndNestedEvents(this IParser parser)
		{
			int num = 0;
			do
			{
				ParsingEvent parsingEvent = parser.Consume<ParsingEvent>();
				num += parsingEvent.NestingIncrease;
			}
			while (num > 0);
		}

		[Obsolete("Please use Consume<T>() instead")]
		public static T Expect<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			return parser.Consume<T>();
		}

		[Obsolete("Please use TryConsume<T>(out var evt) instead")]
		[return: MaybeNull]
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public static T Allow<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.TryConsume<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use Accept<T>(out var evt) instead")]
		[return: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		[return: MaybeNull]
		public static T Peek<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			if (!parser.Accept<T>(out var @event))
			{
				return null;
			}
			return @event;
		}

		[Obsolete("Please use TryConsume<T>(out var evt) or Accept<T>(out var evt) instead")]
		public static bool Accept<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)] T>(this IParser parser) where T : ParsingEvent
		{
			T @event;
			return parser.Accept<T>(out @event);
		}

		public static bool TryFindMappingEntry(this IParser parser, Func<YamlDotNet.Core.Events.Scalar, bool> selector, [MaybeNullWhen(false)][<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out YamlDotNet.Core.Events.Scalar key, [MaybeNullWhen(false)][<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] out ParsingEvent value)
		{
			if (parser.TryConsume<MappingStart>(out var _))
			{
				while (parser.Current != null)
				{
					ParsingEvent current = parser.Current;
					if (!(current is YamlDotNet.Core.Events.Scalar scalar))
					{
						if (current is MappingStart || current is SequenceStart)
						{
							parser.SkipThisAndNestedEvents();
						}
						else
						{
							parser.MoveNext();
						}
						continue;
					}
					bool num = selector(scalar);
					parser.MoveNext();
					if (num)
					{
						value = parser.Current;
						key = scalar;
						return true;
					}
					parser.SkipThisAndNestedEvents();
				}
			}
			key = null;
			value = null;
			return false;
		}
	}
	internal enum ParserState
	{
		StreamStart,
		StreamEnd,
		ImplicitDocumentStart,
		DocumentStart,
		DocumentContent,
		DocumentEnd,
		BlockNode,
		BlockNodeOrIndentlessSequence,
		FlowNode,
		BlockSequenceFirstEntry,
		BlockSequenceEntry,
		IndentlessSequenceEntry,
		BlockMappingFirstKey,
		BlockMappingKey,
		BlockMappingValue,
		FlowSequenceFirstEntry,
		FlowSequenceEntry,
		FlowSequenceEntryMappingKey,
		FlowSequenceEntryMappingValue,
		FlowSequenceEntryMappingEnd,
		FlowMappingFirstKey,
		FlowMappingKey,
		FlowMappingValue,
		FlowMappingEmptyValue
	}
	internal sealed class RecursionLevel
	{
		private int current;

		public int Maximum { get; }

		public RecursionLevel(int maximum)
		{
			Maximum = maximum;
		}

		public void Increment()
		{
			if (!TryIncrement())
			{
				throw new MaximumRecursionLevelReachedException("Maximum level of recursion reached");
			}
		}

		public bool TryIncrement()
		{
			if (current < Maximum)
			{
				current++;
				return true;
			}
			return false;
		}

		public void Decrement()
		{
			if (current == 0)
			{
				throw new InvalidOperationException("Attempted to decrement RecursionLevel to a negative value");
			}
			current--;
		}
	}
	internal enum ScalarStyle
	{
		Any,
		Plain,
		SingleQuoted,
		DoubleQuoted,
		Literal,
		Folded
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class Scanner : IScanner
	{
		private const int MaxVersionNumberLength = 9;

		private static readonly SortedDictionary<char, char> SimpleEscapeCodes = new SortedDictionary<char, char>
		{
			{ '0', '\0' },
			{ 'a', '\a' },
			{ 'b', '\b' },
			{ 't', '\t' },
			{ '\t', '\t' },
			{ 'n', '\n' },
			{ 'v', '\v' },
			{ 'f', '\f' },
			{ 'r', '\r' },
			{ 'e', '\u001b' },
			{ ' ', ' ' },
			{ '"', '"' },
			{ '\\', '\\' },
			{ '/', '/' },
			{ 'N', '\u0085' },
			{ '_', '\u00a0' },
			{ 'L', '\u2028' },
			{ 'P', '\u2029' }
		};

		private readonly Stack<int> indents = new Stack<int>();

		private readonly InsertionQueue<Token> tokens = new InsertionQueue<Token>();

		private readonly Stack<SimpleKey> simpleKeys = new Stack<SimpleKey>();

		private readonly CharacterAnalyzer<LookAheadBuffer> analyzer;

		private readonly Cursor cursor;

		private bool streamStartProduced;

		private bool streamEndProduced;

		private bool plainScalarFollowedByComment;

		private int flowSequenceStartLine;

		private bool flowCollectionFetched;

		private bool startFlowCollectionFetched;

		private int indent = -1;

		private bool flowScalarFetched;

		private bool simpleKeyAllowed;

		private int flowLevel;

		private int tokensParsed;

		private bool tokenAvailable;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private Token previous;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private Anchor previousAnchor;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private YamlDotNet.Core.Tokens.Scalar lastScalar;

		private static readonly byte[] EmptyBytes = new byte[0];

		public bool SkipComments { get; private set; }

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		[field: <f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		public Token Current
		{
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			get;
			[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
			private set;
		}

		public Mark CurrentPosition => cursor.Mark();

		private bool IsDocumentStart()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0 && analyzer.Check('-') && analyzer.Check('-', 1) && analyzer.Check('-', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentEnd()
		{
			if (!analyzer.EndOfInput && cursor.LineOffset == 0 && analyzer.Check('.') && analyzer.Check('.', 1) && analyzer.Check('.', 2))
			{
				return analyzer.IsWhiteBreakOrZero(3);
			}
			return false;
		}

		private bool IsDocumentIndicator()
		{
			if (!IsDocumentStart())
			{
				return IsDocumentEnd();
			}
			return true;
		}

		public Scanner(TextReader input, bool skipComments = true)
		{
			analyzer = new CharacterAnalyzer<LookAheadBuffer>(new LookAheadBuffer(input, 1024));
			cursor = new Cursor();
			SkipComments = skipComments;
		}

		public bool MoveNext()
		{
			if (Current != null)
			{
				ConsumeCurrent();
			}
			return MoveNextWithoutConsuming();
		}

		public bool MoveNextWithoutConsuming()
		{
			if (!tokenAvailable && !streamEndProduced)
			{
				FetchMoreTokens();
			}
			if (tokens.Count > 0)
			{
				Current = tokens.Dequeue();
				tokenAvailable = false;
				return true;
			}
			Current = null;
			return false;
		}

		public void ConsumeCurrent()
		{
			tokensParsed++;
			tokenAvailable = false;
			previous = Current;
			Current = null;
		}

		private char ReadCurrentCharacter()
		{
			char result = analyzer.Peek(0);
			Skip();
			return result;
		}

		private char ReadLine()
		{
			if (analyzer.Check("\r\n\u0085"))
			{
				SkipLine();
				return '\n';
			}
			char result = analyzer.Peek(0);
			SkipLine();
			return result;
		}

		private void FetchMoreTokens()
		{
			while (true)
			{
				bool flag = false;
				if (tokens.Count == 0)
				{
					flag = true;
				}
				else
				{
					foreach (SimpleKey simpleKey in simpleKeys)
					{
						if (simpleKey.IsPossible && simpleKey.TokenNumber == tokensParsed)
						{
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					break;
				}
				FetchNextToken();
			}
			tokenAvailable = true;
		}

		private static bool StartsWith(StringBuilder what, char start)
		{
			if (what.Length > 0)
			{
				return what[0] == start;
			}
			return false;
		}

		private void StaleSimpleKeys()
		{
			foreach (SimpleKey simpleKey in simpleKeys)
			{
				if (simpleKey.IsPossible && (simpleKey.Line < cursor.Line || simpleKey.Index + 1024 < cursor.Index))
				{
					if (simpleKey.IsRequired)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("While scanning a simple key, could not find expected ':'.", mark, mark));
					}
					simpleKey.MarkAsImpossible();
				}
			}
		}

		private void FetchNextToken()
		{
			if (!streamStartProduced)
			{
				FetchStreamStart();
				return;
			}
			ScanToNextToken();
			StaleSimpleKeys();
			UnrollIndent(cursor.LineOffset);
			analyzer.Buffer.Cache(4);
			if (analyzer.Buffer.EndOfInput)
			{
				lastScalar = null;
				FetchStreamEnd();
			}
			if (cursor.LineOffset == 0 && analyzer.Check('%'))
			{
				lastScalar = null;
				FetchDirective();
				return;
			}
			if (IsDocumentStart())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: true);
				return;
			}
			if (IsDocumentEnd())
			{
				lastScalar = null;
				FetchDocumentIndicator(isStartToken: false);
				return;
			}
			if (analyzer.Check('['))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('{'))
			{
				lastScalar = null;
				FetchFlowCollectionStart(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(']'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: true);
				return;
			}
			if (analyzer.Check('}'))
			{
				lastScalar = null;
				FetchFlowCollectionEnd(isSequenceToken: false);
				return;
			}
			if (analyzer.Check(','))
			{
				lastScalar = null;
				FetchFlowEntry();
				return;
			}
			if (analyzer.Check('-'))
			{
				if (analyzer.IsWhiteBreakOrZero(1))
				{
					FetchBlockEntry();
					return;
				}
				if (flowLevel > 0 && analyzer.Check(",[]{}", 1))
				{
					tokens.Enqueue(new Error("Invalid key indicator format.", cursor.Mark(), cursor.Mark()));
				}
			}
			if (analyzer.Check('?') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && analyzer.IsWhiteBreakOrZero(1))
			{
				FetchKey();
			}
			else if (analyzer.Check(':') && (flowLevel > 0 || analyzer.IsWhiteBreakOrZero(1)) && (!simpleKeyAllowed || flowLevel <= 0) && (!flowScalarFetched || !analyzer.Check(':', 1)) && (analyzer.IsWhiteBreakOrZero(1) || analyzer.Check(',', 1) || flowScalarFetched || flowCollectionFetched || startFlowCollectionFetched))
			{
				if (lastScalar != null)
				{
					lastScalar.IsKey = true;
					lastScalar = null;
				}
				FetchValue();
			}
			else if (analyzer.Check('*'))
			{
				FetchAnchor(isAlias: true);
			}
			else if (analyzer.Check('&'))
			{
				FetchAnchor(isAlias: false);
			}
			else if (analyzer.Check('!'))
			{
				FetchTag();
			}
			else if (analyzer.Check('|') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: true);
			}
			else if (analyzer.Check('>') && flowLevel == 0)
			{
				FetchBlockScalar(isLiteral: false);
			}
			else if (analyzer.Check('\''))
			{
				FetchQuotedScalar(isSingleQuoted: true);
			}
			else if (analyzer.Check('"'))
			{
				FetchQuotedScalar(isSingleQuoted: false);
			}
			else if ((!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("-?:,[]{}#&*!|>'\"%@`")) || (analyzer.Check('-') && !analyzer.IsWhite(1)) || (analyzer.Check("?:") && !analyzer.IsWhiteBreakOrZero(1)) || (simpleKeyAllowed && flowLevel > 0))
			{
				if (plainScalarFollowedByComment)
				{
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("While scanning plain scalar, found a comment between adjacent scalars.", mark, mark));
				}
				if ((flowScalarFetched || (flowCollectionFetched && !startFlowCollectionFetched)) && analyzer.Check(':'))
				{
					Skip();
				}
				flowScalarFetched = false;
				flowCollectionFetched = false;
				startFlowCollectionFetched = false;
				plainScalarFollowedByComment = false;
				FetchPlainScalar();
			}
			else
			{
				if (simpleKeyAllowed && indent >= cursor.LineOffset && analyzer.IsTab())
				{
					throw new SyntaxErrorException("While scanning a mapping, found invalid tab as indentation.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark start = cursor.Mark();
					Skip();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning for the next token, found character that cannot start any token.");
				}
				Skip();
			}
		}

		private bool CheckWhiteSpace()
		{
			if (!analyzer.Check(' '))
			{
				if (flowLevel > 0 || !simpleKeyAllowed)
				{
					return analyzer.Check('\t');
				}
				return false;
			}
			return true;
		}

		private void Skip()
		{
			cursor.Skip();
			analyzer.Buffer.Skip(1);
		}

		private void SkipLine()
		{
			if (analyzer.IsCrLf())
			{
				cursor.SkipLineByOffset(2);
				analyzer.Buffer.Skip(2);
			}
			else if (analyzer.IsBreak())
			{
				cursor.SkipLineByOffset(1);
				analyzer.Buffer.Skip(1);
			}
			else if (!analyzer.IsZero())
			{
				throw new InvalidOperationException("Not at a break.");
			}
		}

		private void ScanToNextToken()
		{
			while (true)
			{
				if (CheckWhiteSpace())
				{
					Skip();
					continue;
				}
				ProcessComment();
				if (analyzer.IsBreak())
				{
					SkipLine();
					if (flowLevel == 0)
					{
						simpleKeyAllowed = true;
					}
					continue;
				}
				break;
			}
		}

		private void ProcessComment()
		{
			if (!analyzer.Check('#'))
			{
				return;
			}
			Mark start = cursor.Mark();
			Skip();
			while (analyzer.IsSpace())
			{
				Skip();
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsBreakOrZero())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (!SkipComments)
				{
					bool isInline = previous != null && previous.End.Line == start.Line && previous.End.Column != 1 && !(previous is YamlDotNet.Core.Tokens.StreamStart);
					tokens.Enqueue(new YamlDotNet.Core.Tokens.Comment(builder.ToString(), isInline, start, cursor.Mark()));
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchStreamStart()
		{
			simpleKeys.Push(new SimpleKey());
			simpleKeyAllowed = true;
			streamStartProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamStart(ref start, ref start));
		}

		private void UnrollIndent(int column)
		{
			if (flowLevel == 0)
			{
				while (indent > column)
				{
					Mark start = cursor.Mark();
					tokens.Enqueue(new BlockEnd(ref start, ref start));
					indent = indents.Pop();
				}
			}
		}

		private void FetchStreamEnd()
		{
			cursor.ForceSkipLineAfterNonBreak();
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			streamEndProduced = true;
			Mark start = cursor.Mark();
			tokens.Enqueue(new YamlDotNet.Core.Tokens.StreamEnd(ref start, ref start));
		}

		private void FetchDirective()
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Token token = ScanDirective();
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		private Token ScanDirective()
		{
			Mark start = cursor.Mark();
			Skip();
			string text = ScanDirectiveName(ref start);
			Token result;
			if (!(text == "YAML"))
			{
				if (!(text == "TAG"))
				{
					while (!analyzer.EndOfInput && !analyzer.Check('#') && !analyzer.IsBreak())
					{
						Skip();
					}
					return null;
				}
				result = ScanTagDirectiveValue(ref start);
			}
			else
			{
				if (!(previous is YamlDotNet.Core.Tokens.DocumentStart) && !(previous is YamlDotNet.Core.Tokens.StreamStart) && !(previous is YamlDotNet.Core.Tokens.DocumentEnd))
				{
					Mark end = cursor.Mark();
					throw new SemanticErrorException(ref start, ref end, "While scanning a version directive, did not find preceding <document end>.");
				}
				result = ScanVersionDirectiveValue(ref start);
			}
			while (analyzer.IsWhite())
			{
				Skip();
			}
			ProcessComment();
			if (!analyzer.IsBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a directive, did not find expected comment or line break.");
			}
			if (analyzer.IsBreak())
			{
				SkipLine();
			}
			return result;
		}

		private void FetchDocumentIndicator(bool isStartToken)
		{
			UnrollIndent(-1);
			RemoveSimpleKey();
			simpleKeyAllowed = false;
			Mark end = cursor.Mark();
			Skip();
			Skip();
			Skip();
			if (isStartToken)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				Mark end2 = cursor.Mark();
				insertionQueue.Enqueue(new YamlDotNet.Core.Tokens.DocumentStart(ref end, ref end2));
				return;
			}
			Token token = null;
			while (!analyzer.EndOfInput && !analyzer.IsBreak() && !analyzer.Check('#'))
			{
				if (!analyzer.IsWhite())
				{
					token = new Error("While scanning a document end, found invalid content after '...' marker.", end, cursor.Mark());
					break;
				}
				Skip();
			}
			tokens.Enqueue(new YamlDotNet.Core.Tokens.DocumentEnd(ref end, ref end));
			if (token != null)
			{
				tokens.Enqueue(token);
			}
		}

		private void FetchFlowCollectionStart(bool isSequenceToken)
		{
			SaveSimpleKey();
			IncreaseFlowLevel();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Token token;
			if (isSequenceToken)
			{
				token = new FlowSequenceStart(ref start, ref start);
				flowSequenceStartLine = token.Start.Line;
			}
			else
			{
				token = new FlowMappingStart(ref start, ref start);
			}
			tokens.Enqueue(token);
			startFlowCollectionFetched = true;
		}

		private void IncreaseFlowLevel()
		{
			simpleKeys.Push(new SimpleKey());
			flowLevel++;
		}

		private void FetchFlowCollectionEnd(bool isSequenceToken)
		{
			RemoveSimpleKey();
			DecreaseFlowLevel();
			simpleKeyAllowed = false;
			Mark start = cursor.Mark();
			Skip();
			Token token = null;
			Token item;
			if (isSequenceToken)
			{
				if (analyzer.Check('#'))
				{
					token = new Error("While scanning a flow sequence end, found invalid comment after ']'.", start, start);
				}
				item = new FlowSequenceEnd(ref start, ref start);
			}
			else
			{
				item = new FlowMappingEnd(ref start, ref start);
			}
			tokens.Enqueue(item);
			if (token != null)
			{
				tokens.Enqueue(token);
			}
			flowCollectionFetched = true;
		}

		private void DecreaseFlowLevel()
		{
			if (flowLevel > 0)
			{
				flowLevel--;
				simpleKeys.Pop();
			}
		}

		private void FetchFlowEntry()
		{
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start = cursor.Mark();
			Skip();
			Mark end = cursor.Mark();
			if (analyzer.Check('#'))
			{
				tokens.Enqueue(new Error("While scanning a flow entry, found invalid comment after comma.", start, end));
			}
			else
			{
				tokens.Enqueue(new FlowEntry(ref start, ref end));
			}
		}

		private void FetchBlockEntry()
		{
			Mark start;
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					if (previousAnchor != null && previousAnchor.End.Line == cursor.Line)
					{
						start = previousAnchor.Start;
						Mark end = previousAnchor.End;
						throw new SemanticErrorException(ref start, ref end, "Anchor before sequence entry on same line is not allowed.");
					}
					Mark mark = cursor.Mark();
					tokens.Enqueue(new Error("Block sequence entries are not allowed in this context.", mark, mark));
				}
				RollIndent(cursor.LineOffset, -1, isSequence: true, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = true;
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue = tokens;
			start = cursor.Mark();
			insertionQueue.Enqueue(new BlockEntry(ref start2, ref start));
		}

		private void FetchKey()
		{
			if (flowLevel == 0)
			{
				if (!simpleKeyAllowed)
				{
					Mark start = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref start, "Mapping keys are not allowed in this context.");
				}
				RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
			}
			RemoveSimpleKey();
			simpleKeyAllowed = flowLevel == 0;
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue = tokens;
			Mark end = cursor.Mark();
			insertionQueue.Enqueue(new Key(ref start2, ref end));
		}

		private void FetchValue()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			Mark start;
			if (simpleKey.IsPossible)
			{
				InsertionQueue<Token> insertionQueue = tokens;
				int index = simpleKey.TokenNumber - tokensParsed;
				start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				insertionQueue.Insert(index, new Key(ref start, ref end));
				RollIndent(simpleKey.LineOffset, simpleKey.TokenNumber, isSequence: false, simpleKey.Mark);
				simpleKey.MarkAsImpossible();
				simpleKeyAllowed = false;
			}
			else
			{
				bool flag = flowLevel == 0;
				if (flag)
				{
					if (!simpleKeyAllowed)
					{
						Mark mark = cursor.Mark();
						tokens.Enqueue(new Error("Mapping values are not allowed in this context.", mark, mark));
						return;
					}
					RollIndent(cursor.LineOffset, -1, isSequence: false, cursor.Mark());
					if (cursor.LineOffset == 0 && simpleKey.LineOffset == 0)
					{
						InsertionQueue<Token> insertionQueue2 = tokens;
						int count = tokens.Count;
						start = simpleKey.Mark;
						Mark end = simpleKey.Mark;
						insertionQueue2.Insert(count, new Key(ref start, ref end));
						flag = false;
					}
				}
				simpleKeyAllowed = flag;
			}
			Mark start2 = cursor.Mark();
			Skip();
			InsertionQueue<Token> insertionQueue3 = tokens;
			start = cursor.Mark();
			insertionQueue3.Enqueue(new Value(ref start2, ref start));
		}

		private void RollIndent(int column, int number, bool isSequence, Mark position)
		{
			if (flowLevel <= 0 && indent < column)
			{
				indents.Push(indent);
				indent = column;
				Token item = ((!isSequence) ? ((Token)new BlockMappingStart(ref position, ref position)) : ((Token)new BlockSequenceStart(ref position, ref position)));
				if (number == -1)
				{
					tokens.Enqueue(item);
				}
				else
				{
					tokens.Insert(number - tokensParsed, item);
				}
			}
		}

		private void FetchAnchor(bool isAlias)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanAnchor(isAlias));
		}

		private Token ScanAnchor(bool isAlias)
		{
			Mark start = cursor.Mark();
			Skip();
			bool flag = false;
			if (isAlias)
			{
				SimpleKey simpleKey = simpleKeys.Peek();
				flag = simpleKey.IsRequired && simpleKey.IsPossible;
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("[]{},") && (!flag || !analyzer.Check(':') || !analyzer.IsWhiteBreakOrZero(1)))
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0 || (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check("?:,]}%@`")))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning an anchor or alias, found value containing disallowed: []{},");
				}
				AnchorName value = new AnchorName(builder.ToString());
				if (isAlias)
				{
					return new YamlDotNet.Core.Tokens.AnchorAlias(value, start, cursor.Mark());
				}
				return previousAnchor = new Anchor(value, start, cursor.Mark());
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchTag()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			tokens.Enqueue(ScanTag());
		}

		private Token ScanTag()
		{
			Mark start = cursor.Mark();
			string text;
			string text2;
			if (analyzer.Check('<', 1))
			{
				text = string.Empty;
				Skip();
				Skip();
				text2 = ScanTagUri(null, start);
				if (!analyzer.Check('>'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a tag, did not find the expected '>'.");
				}
				Skip();
			}
			else
			{
				string text3 = ScanTagHandle(isDirective: false, start);
				if (text3.Length > 1 && text3[0] == '!' && text3[text3.Length - 1] == '!')
				{
					text = text3;
					text2 = ScanTagUri(null, start);
				}
				else
				{
					text2 = ScanTagUri(text3, start);
					text = "!";
					if (text2.Length == 0)
					{
						text2 = text;
						text = string.Empty;
					}
				}
			}
			if (!analyzer.IsWhiteBreakOrZero() && !analyzer.Check(','))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a tag, did not find expected whitespace, comma or line break.");
			}
			return new Tag(text, text2, start, cursor.Mark());
		}

		private void FetchBlockScalar(bool isLiteral)
		{
			SaveSimpleKey();
			simpleKeyAllowed = true;
			tokens.Enqueue(ScanBlockScalar(isLiteral));
		}

		private Token ScanBlockScalar(bool isLiteral)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						int num = 0;
						int num2 = 0;
						int currentIndent = 0;
						bool flag = false;
						bool? isFirstLine = null;
						Mark start = cursor.Mark();
						Skip();
						if (analyzer.Check("+-"))
						{
							num = (analyzer.Check('+') ? 1 : (-1));
							Skip();
							if (analyzer.IsDigit())
							{
								if (analyzer.Check('0'))
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(ref start, ref end, "While scanning a block scalar, found an indentation indicator equal to 0.");
								}
								num2 = analyzer.AsDigit();
								Skip();
							}
						}
						else if (analyzer.IsDigit())
						{
							if (analyzer.Check('0'))
							{
								Mark end = cursor.Mark();
								throw new SyntaxErrorException(ref start, ref end, "While scanning a block scalar, found an indentation indicator equal to 0.");
							}
							num2 = analyzer.AsDigit();
							Skip();
							if (analyzer.Check("+-"))
							{
								num = (analyzer.Check('+') ? 1 : (-1));
								Skip();
							}
						}
						if (analyzer.Check('#'))
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(ref start, ref end, "While scanning a block scalar, found a comment without whtespace after '>' indicator.");
						}
						while (analyzer.IsWhite())
						{
							Skip();
						}
						ProcessComment();
						if (!analyzer.IsBreakOrZero())
						{
							Mark end = cursor.Mark();
							throw new SyntaxErrorException(ref start, ref end, "While scanning a block scalar, did not find expected comment or line break.");
						}
						if (analyzer.IsBreak())
						{
							SkipLine();
							if (!isFirstLine.HasValue)
							{
								isFirstLine = true;
							}
							else if (isFirstLine == true)
							{
								isFirstLine = false;
							}
						}
						Mark end2 = cursor.Mark();
						if (num2 != 0)
						{
							currentIndent = ((indent >= 0) ? (indent + num2) : num2);
						}
						currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						isFirstLine = false;
						while (cursor.LineOffset == currentIndent && !analyzer.IsZero() && !IsDocumentEnd())
						{
							bool flag2 = analyzer.IsWhite();
							if (!isLiteral && StartsWith(builder2, '\n') && !flag && !flag2)
							{
								if (builder3.Length == 0)
								{
									builder.Append(' ');
								}
								builder2.Length = 0;
							}
							else
							{
								builder.Append(builder2.ToString());
								builder2.Length = 0;
							}
							builder.Append(builder3.ToString());
							builder3.Length = 0;
							flag = analyzer.IsWhite();
							while (!analyzer.IsBreakOrZero())
							{
								builder.Append(ReadCurrentCharacter());
							}
							char c = ReadLine();
							if (c != 0)
							{
								builder2.Append(c);
							}
							currentIndent = ScanBlockScalarBreaks(currentIndent, builder3, isLiteral, ref end2, ref isFirstLine);
						}
						if (num != -1)
						{
							builder.Append((object?)builder2);
						}
						if (num == 1)
						{
							builder.Append((object?)builder3);
						}
						ScalarStyle style = (isLiteral ? ScalarStyle.Literal : ScalarStyle.Folded);
						return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), style, start, end2);
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanBlockScalarBreaks(int currentIndent, StringBuilder breaks, bool isLiteral, ref Mark end, ref bool? isFirstLine)
		{
			int num = 0;
			int num2 = -1;
			end = cursor.Mark();
			while (true)
			{
				if ((currentIndent == 0 || cursor.LineOffset < currentIndent) && analyzer.IsSpace())
				{
					Skip();
					continue;
				}
				if (cursor.LineOffset > num)
				{
					num = cursor.LineOffset;
				}
				if (!analyzer.IsBreak())
				{
					break;
				}
				if (isFirstLine == true)
				{
					isFirstLine = false;
					num2 = cursor.LineOffset;
				}
				breaks.Append(ReadLine());
				end = cursor.Mark();
			}
			if (isLiteral && isFirstLine == true)
			{
				int num3 = cursor.LineOffset;
				int num4 = 0;
				while (!analyzer.IsBreak(num4) && analyzer.IsSpace(num4))
				{
					num4++;
					num3++;
				}
				if (analyzer.IsBreak(num4) && num3 > cursor.LineOffset)
				{
					isFirstLine = false;
					num2 = num3;
				}
			}
			if (isLiteral && num2 > 1 && currentIndent < num2 - 1)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(ref end, ref end2, "While scanning a literal block scalar, found extra spaces in first line.");
			}
			if (!isLiteral && num > cursor.LineOffset && num2 > -1)
			{
				Mark end2 = cursor.Mark();
				throw new SemanticErrorException(ref end, ref end2, "While scanning a literal block scalar, found more spaces in lines above first content line.");
			}
			if (currentIndent == 0 && (cursor.LineOffset > 0 || indent > -1))
			{
				currentIndent = Math.Max(num, Math.Max(indent + 1, 1));
			}
			return currentIndent;
		}

		private void FetchQuotedScalar(bool isSingleQuoted)
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			flowScalarFetched = flowLevel > 0;
			YamlDotNet.Core.Tokens.Scalar item = ScanFlowScalar(isSingleQuoted);
			tokens.Enqueue(item);
			lastScalar = item;
			if (!isSingleQuoted && analyzer.Check('#'))
			{
				Mark mark = cursor.Mark();
				tokens.Enqueue(new Error("While scanning a flow sequence end, found invalid comment after double-quoted scalar.", mark, mark));
			}
		}

		private YamlDotNet.Core.Tokens.Scalar ScanFlowScalar(bool isSingleQuoted)
		{
			Mark start = cursor.Mark();
			Skip();
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							while (true)
							{
								if (IsDocumentIndicator())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(ref start, ref end, "While scanning a quoted scalar, found unexpected document indicator.");
								}
								if (analyzer.IsZero())
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(ref start, ref end, "While scanning a quoted scalar, found unexpected end of stream.");
								}
								if (flag && !isSingleQuoted && indent >= cursor.LineOffset)
								{
									Mark end = cursor.Mark();
									throw new SyntaxErrorException(ref start, ref end, "While scanning a multi-line double-quoted scalar, found wrong indentation.");
								}
								flag = false;
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if (isSingleQuoted && analyzer.Check('\'') && analyzer.Check('\'', 1))
									{
										builder.Append('\'');
										Skip();
										Skip();
										continue;
									}
									if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
									{
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\') && analyzer.IsBreak(1))
									{
										Skip();
										SkipLine();
										flag = true;
										break;
									}
									if (!isSingleQuoted && analyzer.Check('\\'))
									{
										int num = 0;
										char c = analyzer.Peek(1);
										switch (c)
										{
										case 'x':
											num = 2;
											break;
										case 'u':
											num = 4;
											break;
										case 'U':
											num = 8;
											break;
										default:
										{
											if (SimpleEscapeCodes.TryGetValue(c, out var value))
											{
												builder.Append(value);
												break;
											}
											Mark end = cursor.Mark();
											throw new SyntaxErrorException(ref start, ref end, "While scanning a quoted scalar, found unknown escape character.");
										}
										}
										Skip();
										Skip();
										if (num <= 0)
										{
											continue;
										}
										int num2 = 0;
										for (int i = 0; i < num; i++)
										{
											if (!analyzer.IsHex(i))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(ref start, ref end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
											}
											num2 = (num2 << 4) + analyzer.AsHex(i);
										}
										if (num2 >= 55296 && num2 <= 57343)
										{
											for (int j = 0; j < num; j++)
											{
												Skip();
											}
											if (analyzer.Peek(0) != '\\' || (analyzer.Peek(1) != 'u' && analyzer.Peek(1) != 'U'))
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(ref start, ref end, "While scanning a quoted scalar, found invalid Unicode surrogates.");
											}
											Skip();
											num = ((analyzer.Peek(0) != 'u') ? 8 : 4);
											Skip();
											int num3 = 0;
											for (int k = 0; k < num; k++)
											{
												if (!analyzer.IsHex(0))
												{
													Mark end = cursor.Mark();
													throw new SyntaxErrorException(ref start, ref end, "While scanning a quoted scalar, did not find expected hexadecimal number.");
												}
												num3 = (num3 << 4) + analyzer.AsHex(k);
											}
											for (int l = 0; l < num; l++)
											{
												Skip();
											}
											num2 = char.ConvertToUtf32((char)num2, (char)num3);
										}
										else
										{
											if (num2 > 1114111)
											{
												Mark end = cursor.Mark();
												throw new SyntaxErrorException(ref start, ref end, "While scanning a quoted scalar, found invalid Unicode character escape code.");
											}
											for (int m = 0; m < num; m++)
											{
												Skip();
											}
										}
										builder.Append(char.ConvertFromUtf32(num2));
									}
									else
									{
										builder.Append(ReadCurrentCharacter());
									}
								}
								if (analyzer.Check(isSingleQuoted ? '\'' : '"'))
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else if (!flag)
									{
										builder2.Length = 0;
										builder3.Append(ReadLine());
										flag = true;
									}
									else
									{
										builder4.Append(ReadLine());
									}
								}
								if (flag)
								{
									if (StartsWith(builder3, '\n'))
									{
										if (builder4.Length == 0)
										{
											builder.Append(' ');
										}
										else
										{
											builder.Append(builder4.ToString());
										}
									}
									else
									{
										builder.Append(builder3.ToString());
										builder.Append(builder4.ToString());
									}
									builder3.Length = 0;
									builder4.Length = 0;
								}
								else
								{
									builder.Append(builder2.ToString());
									builder2.Length = 0;
								}
							}
							Skip();
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), isSingleQuoted ? ScalarStyle.SingleQuoted : ScalarStyle.DoubleQuoted, start, cursor.Mark());
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void FetchPlainScalar()
		{
			SaveSimpleKey();
			simpleKeyAllowed = false;
			bool isMultiline = false;
			YamlDotNet.Core.Tokens.Scalar item = (lastScalar = ScanPlainScalar(ref isMultiline));
			if (isMultiline && analyzer.Check(':') && flowLevel == 0 && indent < cursor.LineOffset)
			{
				tokens.Enqueue(new Error("While scanning a multiline plain scalar, found invalid mapping.", cursor.Mark(), cursor.Mark()));
			}
			tokens.Enqueue(item);
		}

		private YamlDotNet.Core.Tokens.Scalar ScanPlainScalar(ref bool isMultiline)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				StringBuilderPool.BuilderWrapper builderWrapper2 = StringBuilderPool.Rent();
				try
				{
					StringBuilder builder2 = builderWrapper2.Builder;
					StringBuilderPool.BuilderWrapper builderWrapper3 = StringBuilderPool.Rent();
					try
					{
						StringBuilder builder3 = builderWrapper3.Builder;
						StringBuilderPool.BuilderWrapper builderWrapper4 = StringBuilderPool.Rent();
						try
						{
							StringBuilder builder4 = builderWrapper4.Builder;
							bool flag = false;
							int num = indent + 1;
							Mark start = cursor.Mark();
							Mark end = start;
							SimpleKey simpleKey = simpleKeys.Peek();
							while (!IsDocumentIndicator())
							{
								if (analyzer.Check('#'))
								{
									if (indent < 0 && flowLevel == 0)
									{
										plainScalarFollowedByComment = true;
									}
									break;
								}
								bool flag2 = analyzer.Check('*') && (!simpleKey.IsPossible || !simpleKey.IsRequired);
								while (!analyzer.IsWhiteBreakOrZero())
								{
									if ((analyzer.Check(':') && !flag2 && (analyzer.IsWhiteBreakOrZero(1) || (flowLevel > 0 && analyzer.Check(',', 1)))) || (flowLevel > 0 && analyzer.Check(",[]{}")))
									{
										if (flowLevel == 0 && !simpleKey.IsPossible)
										{
											tokens.Enqueue(new Error("While scanning a plain scalar value, found invalid mapping.", cursor.Mark(), cursor.Mark()));
										}
										break;
									}
									if (flag || builder2.Length > 0)
									{
										if (flag)
										{
											if (StartsWith(builder3, '\n'))
											{
												if (builder4.Length == 0)
												{
													builder.Append(' ');
												}
												else
												{
													builder.Append((object?)builder4);
												}
											}
											else
											{
												builder.Append((object?)builder3);
												builder.Append((object?)builder4);
											}
											builder3.Length = 0;
											builder4.Length = 0;
											flag = false;
										}
										else
										{
											builder.Append((object?)builder2);
											builder2.Length = 0;
										}
									}
									if (flowLevel > 0 && cursor.LineOffset < num)
									{
										throw new Exception();
									}
									builder.Append(ReadCurrentCharacter());
									end = cursor.Mark();
								}
								if (!analyzer.IsWhite() && !analyzer.IsBreak())
								{
									break;
								}
								while (analyzer.IsWhite() || analyzer.IsBreak())
								{
									if (analyzer.IsWhite())
									{
										if (flag && cursor.LineOffset < num && analyzer.IsTab())
										{
											Mark end2 = cursor.Mark();
											throw new SyntaxErrorException(ref start, ref end2, "While scanning a plain scalar, found a tab character that violate indentation.");
										}
										if (!flag)
										{
											builder2.Append(ReadCurrentCharacter());
										}
										else
										{
											Skip();
										}
									}
									else
									{
										isMultiline = true;
										if (!flag)
										{
											builder2.Length = 0;
											builder3.Append(ReadLine());
											flag = true;
										}
										else
										{
											builder4.Append(ReadLine());
										}
									}
								}
								if (flowLevel == 0 && cursor.LineOffset < num)
								{
									break;
								}
							}
							if (flag)
							{
								simpleKeyAllowed = true;
							}
							return new YamlDotNet.Core.Tokens.Scalar(builder.ToString(), ScalarStyle.Plain, start, end);
						}
						finally
						{
							((IDisposable)builderWrapper4).Dispose();
						}
					}
					finally
					{
						((IDisposable)builderWrapper3).Dispose();
					}
				}
				finally
				{
					((IDisposable)builderWrapper2).Dispose();
				}
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void RemoveSimpleKey()
		{
			SimpleKey simpleKey = simpleKeys.Peek();
			if (simpleKey.IsPossible && simpleKey.IsRequired)
			{
				Mark start = simpleKey.Mark;
				Mark end = simpleKey.Mark;
				throw new SyntaxErrorException(ref start, ref end, "While scanning a simple key, could not find expected ':'.");
			}
			simpleKey.MarkAsImpossible();
		}

		private string ScanDirectiveName([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (builder.Length == 0)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a directive, could not find expected directive name.");
				}
				if (analyzer.EndOfInput)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a directive, found unexpected end of stream.");
				}
				if (!analyzer.IsWhiteBreakOrZero())
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a directive, found unexpected non-alphabetical character.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private void SkipWhitespaces()
		{
			while (analyzer.IsWhite())
			{
				Skip();
			}
		}

		private Token ScanVersionDirectiveValue([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start)
		{
			SkipWhitespaces();
			int major = ScanVersionDirectiveNumber(ref start);
			if (!analyzer.Check('.'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a %YAML directive, did not find expected digit or '.' character.");
			}
			Skip();
			int minor = ScanVersionDirectiveNumber(ref start);
			return new VersionDirective(new Version(major, minor), start, start);
		}

		private Token ScanTagDirectiveValue([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start)
		{
			SkipWhitespaces();
			string handle = ScanTagHandle(isDirective: true, start);
			if (!analyzer.IsWhite())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a %TAG directive, did not find expected whitespace.");
			}
			SkipWhitespaces();
			string prefix = ScanTagUri(null, start);
			if (!analyzer.IsWhiteBreakOrZero())
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a %TAG directive, did not find expected whitespace or line break.");
			}
			return new TagDirective(handle, prefix, start, start);
		}

		private string ScanTagUri([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] string head, Mark start)
		{
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				if (head != null && head.Length > 1)
				{
					builder.Append(head.Substring(1));
				}
				while (analyzer.IsAlphaNumericDashOrUnderscore() || analyzer.Check(";/?:@&=+$.!~*'()[]%") || (analyzer.Check(',') && !analyzer.IsBreak(1)))
				{
					if (analyzer.Check('%'))
					{
						builder.Append(ScanUriEscapes(ref start));
					}
					else if (analyzer.Check('+'))
					{
						builder.Append(' ');
						Skip();
					}
					else
					{
						builder.Append(ReadCurrentCharacter());
					}
				}
				if (builder.Length == 0)
				{
					return string.Empty;
				}
				string text = builder.ToString();
				if (text.EndsWith(","))
				{
					Mark start2 = cursor.Mark();
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start2, ref end, "Unexpected comma at end of tag");
				}
				return text;
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private string ScanUriEscapes([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start)
		{
			byte[] array = EmptyBytes;
			int count = 0;
			int num = 0;
			do
			{
				if (!analyzer.Check('%') || !analyzer.IsHex(1) || !analyzer.IsHex(2))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a tag, did not find URI escaped octet.");
				}
				int num2 = (analyzer.AsHex(1) << 4) + analyzer.AsHex(2);
				if (num == 0)
				{
					num = (((num2 & 0x80) == 0) ? 1 : (((num2 & 0xE0) == 192) ? 2 : (((num2 & 0xF0) == 224) ? 3 : (((num2 & 0xF8) == 240) ? 4 : 0))));
					if (num == 0)
					{
						Mark end = cursor.Mark();
						throw new SyntaxErrorException(ref start, ref end, "While scanning a tag, found an incorrect leading UTF-8 octet.");
					}
					array = new byte[num];
				}
				else if ((num2 & 0xC0) != 128)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a tag, found an incorrect trailing UTF-8 octet.");
				}
				array[count++] = (byte)num2;
				Skip();
				Skip();
				Skip();
			}
			while (--num > 0);
			string @string = Encoding.UTF8.GetString(array, 0, count);
			if (@string.Length == 0 || @string.Length > 2)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a tag, found an incorrect UTF-8 sequence.");
			}
			return @string;
		}

		private string ScanTagHandle(bool isDirective, Mark start)
		{
			if (!analyzer.Check('!'))
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a tag, did not find expected '!'.");
			}
			StringBuilderPool.BuilderWrapper builderWrapper = StringBuilderPool.Rent();
			try
			{
				StringBuilder builder = builderWrapper.Builder;
				builder.Append(ReadCurrentCharacter());
				while (analyzer.IsAlphaNumericDashOrUnderscore())
				{
					builder.Append(ReadCurrentCharacter());
				}
				if (analyzer.Check('!'))
				{
					builder.Append(ReadCurrentCharacter());
				}
				else if (isDirective && (builder.Length != 1 || builder[0] != '!'))
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a tag directive, did not find expected '!'.");
				}
				return builder.ToString();
			}
			finally
			{
				((IDisposable)builderWrapper).Dispose();
			}
		}

		private int ScanVersionDirectiveNumber([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start)
		{
			int num = 0;
			int num2 = 0;
			while (analyzer.IsDigit())
			{
				if (++num2 > 9)
				{
					Mark end = cursor.Mark();
					throw new SyntaxErrorException(ref start, ref end, "While scanning a %YAML directive, found extremely long version number.");
				}
				num = num * 10 + analyzer.AsDigit();
				Skip();
			}
			if (num2 == 0)
			{
				Mark end = cursor.Mark();
				throw new SyntaxErrorException(ref start, ref end, "While scanning a %YAML directive, did not find expected version number.");
			}
			return num;
		}

		private void SaveSimpleKey()
		{
			bool isRequired = flowLevel == 0 && indent == cursor.LineOffset;
			if (simpleKeyAllowed)
			{
				SimpleKey item = new SimpleKey(isRequired, tokensParsed + tokens.Count, cursor);
				RemoveSimpleKey();
				simpleKeys.Pop();
				simpleKeys.Push(item);
			}
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal class SemanticErrorException : YamlException
	{
		public SemanticErrorException(string message)
			: base(message)
		{
		}

		public SemanticErrorException([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end, string message)
			: base(ref start, ref end, message)
		{
		}

		public SemanticErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class SimpleKey
	{
		private readonly Cursor cursor;

		public bool IsPossible { get; private set; }

		public bool IsRequired { get; }

		public int TokenNumber { get; }

		public int Index => cursor.Index;

		public int Line => cursor.Line;

		public int LineOffset => cursor.LineOffset;

		public Mark Mark => cursor.Mark();

		public void MarkAsImpossible()
		{
			IsPossible = false;
		}

		public SimpleKey()
		{
			cursor = new Cursor();
		}

		public SimpleKey(bool isRequired, int tokenNumber, Cursor cursor)
		{
			IsPossible = true;
			IsRequired = isRequired;
			TokenNumber = tokenNumber;
			this.cursor = new Cursor(cursor);
		}
	}
	internal sealed class StringLookAheadBuffer : ILookAheadBuffer
	{
		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(1)]
		private readonly string value;

		public int Position { get; private set; }

		public int Length => value.Length;

		public bool EndOfInput => IsOutside(Position);

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public StringLookAheadBuffer(string value)
		{
			this.value = value;
		}

		public char Peek(int offset)
		{
			int index = Position + offset;
			if (!IsOutside(index))
			{
				return value[index];
			}
			return '\0';
		}

		private bool IsOutside(int index)
		{
			return index >= value.Length;
		}

		public void Skip(int length)
		{
			if (length < 0)
			{
				throw new ArgumentOutOfRangeException("length", "The length must be positive.");
			}
			Position += length;
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class SyntaxErrorException : YamlException
	{
		public SyntaxErrorException(string message)
			: base(message)
		{
		}

		public SyntaxErrorException([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end, string message)
			: base(ref start, ref end, message)
		{
		}

		public SyntaxErrorException(string message, Exception inner)
			: base(message, inner)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })]
	internal sealed class TagDirectiveCollection : KeyedCollection<string, TagDirective>
	{
		public TagDirectiveCollection()
		{
		}

		public TagDirectiveCollection(IEnumerable<TagDirective> tagDirectives)
		{
			foreach (TagDirective tagDirective in tagDirectives)
			{
				Add(tagDirective);
			}
		}

		protected override string GetKeyForItem(TagDirective item)
		{
			return item.Handle;
		}

		public new bool Contains(TagDirective directive)
		{
			return Contains(GetKeyForItem(directive));
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly]
	internal struct TagName : IEquatable<TagName>
	{
		public static readonly TagName Empty;

		[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)]
		private readonly string value;

		public string Value => value ?? throw new InvalidOperationException("Cannot read the Value of a non-specific tag");

		public bool IsEmpty => value == null;

		public bool IsNonSpecific
		{
			get
			{
				if (!IsEmpty)
				{
					if (!(value == "!"))
					{
						return value == "?";
					}
					return true;
				}
				return false;
			}
		}

		public bool IsLocal
		{
			get
			{
				if (!IsEmpty)
				{
					return Value[0] == '!';
				}
				return false;
			}
		}

		public bool IsGlobal
		{
			get
			{
				if (!IsEmpty)
				{
					return !IsLocal;
				}
				return false;
			}
		}

		public TagName(string value)
		{
			this.value = value ?? throw new ArgumentNullException("value");
			if (value.Length == 0)
			{
				throw new ArgumentException("Tag value must not be empty.", "value");
			}
			if (IsGlobal && !Uri.IsWellFormedUriString(value, UriKind.RelativeOrAbsolute))
			{
				throw new ArgumentException("Global tags must be valid URIs.", "value");
			}
		}

		public override string ToString()
		{
			return value ?? "?";
		}

		public bool Equals(TagName other)
		{
			return object.Equals(value, other.value);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is TagName other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return value?.GetHashCode() ?? 0;
		}

		public static bool operator ==(TagName left, TagName right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(TagName left, TagName right)
		{
			return !(left == right);
		}

		public static bool operator ==(TagName left, string right)
		{
			return object.Equals(left.value, right);
		}

		public static bool operator !=(TagName left, string right)
		{
			return !(left == right);
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public static implicit operator TagName(string value)
		{
			if (value != null)
			{
				return new TagName(value);
			}
			return Empty;
		}
	}
	internal sealed class Version
	{
		public int Major { get; }

		public int Minor { get; }

		public Version(int major, int minor)
		{
			if (major < 0)
			{
				throw new ArgumentOutOfRangeException("major", $"{major} should be >= 0");
			}
			Major = major;
			if (minor < 0)
			{
				throw new ArgumentOutOfRangeException("minor", $"{minor} should be >= 0");
			}
			Minor = minor;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is Version version && Major == version.Major)
			{
				return Minor == version.Minor;
			}
			return false;
		}

		public override int GetHashCode()
		{
			return HashCode.CombineHashCodes(Major.GetHashCode(), Minor.GetHashCode());
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class YamlException : Exception
	{
		public Mark Start { get; }

		public Mark End { get; }

		public YamlException(string message)
			: this(ref Mark.Empty, ref Mark.Empty, message)
		{
		}

		public YamlException([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end, string message)
			: this(ref start, ref end, message, null)
		{
		}

		public YamlException([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end, string message, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] Exception innerException)
			: base(message, innerException)
		{
			Start = start;
			End = end;
		}

		public YamlException(string message, Exception inner)
			: this(ref Mark.Empty, ref Mark.Empty, message, inner)
		{
		}

		public override string ToString()
		{
			return $"({Start}) - ({End}): {Message}";
		}
	}
}
namespace YamlDotNet.Core.Tokens
{
	internal class Anchor : Token
	{
		public AnchorName Value { get; }

		public Anchor(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public Anchor(AnchorName value, Mark start, Mark end)
			: base(ref start, ref end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class AnchorAlias : Token
	{
		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(ref start, ref end)
		{
			if (value.IsEmpty)
			{
				throw new ArgumentNullException("value");
			}
			Value = value;
		}
	}
	internal sealed class BlockEnd : Token
	{
		public BlockEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public BlockEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class BlockEntry : Token
	{
		public BlockEntry()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public BlockEntry([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class BlockMappingStart : Token
	{
		public BlockMappingStart()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public BlockMappingStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class BlockSequenceStart : Token
	{
		public BlockSequenceStart()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public BlockSequenceStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class Comment : Token
	{
		public string Value { get; }

		public bool IsInline { get; }

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			IsInline = isInline;
		}
	}
	internal sealed class DocumentEnd : Token
	{
		public DocumentEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public DocumentEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class DocumentStart : Token
	{
		public DocumentStart()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public DocumentStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class Error : Token
	{
		public string Value { get; }

		public Error(string value, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Value = value;
		}
	}
	internal sealed class FlowEntry : Token
	{
		public FlowEntry()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public FlowEntry([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class FlowMappingEnd : Token
	{
		public FlowMappingEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public FlowMappingEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class FlowMappingStart : Token
	{
		public FlowMappingStart()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public FlowMappingStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class FlowSequenceEnd : Token
	{
		public FlowSequenceEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public FlowSequenceEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class FlowSequenceStart : Token
	{
		public FlowSequenceStart()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public FlowSequenceStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class Key : Token
	{
		public Key()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public Key([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class Scalar : Token
	{
		public bool IsKey { get; set; }

		public string Value { get; }

		public ScalarStyle Style { get; }

		public Scalar(string value)
			: this(value, ScalarStyle.Any)
		{
		}

		public Scalar(string value, ScalarStyle style)
			: this(value, style, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value, ScalarStyle style, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Value = value ?? throw new ArgumentNullException("value");
			Style = style;
		}
	}
	internal sealed class StreamEnd : Token
	{
		public StreamEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public StreamEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	internal sealed class StreamStart : Token
	{
		public StreamStart()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public StreamStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class Tag : Token
	{
		public string Handle { get; }

		public string Suffix { get; }

		public Tag(string handle, string suffix)
			: this(handle, suffix, Mark.Empty, Mark.Empty)
		{
		}

		public Tag(string handle, string suffix, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Handle = handle ?? throw new ArgumentNullException("handle");
			Suffix = suffix ?? throw new ArgumentNullException("suffix");
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class TagDirective : Token
	{
		private static readonly Regex TagHandlePattern = new Regex("^!([0-9A-Za-z_\\-]*!)?$", RegexOptions.Compiled);

		public string Handle { get; }

		public string Prefix { get; }

		public TagDirective(string handle, string prefix)
			: this(handle, prefix, Mark.Empty, Mark.Empty)
		{
		}

		public TagDirective(string handle, string prefix, Mark start, Mark end)
			: base(ref start, ref end)
		{
			if (string.IsNullOrEmpty(handle))
			{
				throw new ArgumentNullException("handle", "Tag handle must not be empty.");
			}
			if (!TagHandlePattern.IsMatch(handle))
			{
				throw new ArgumentException("Tag handle must start and end with '!' and contain alphanumerical characters only.", "handle");
			}
			Handle = handle;
			if (string.IsNullOrEmpty(prefix))
			{
				throw new ArgumentNullException("prefix", "Tag prefix must not be empty.");
			}
			Prefix = prefix;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is TagDirective tagDirective && Handle.Equals(tagDirective.Handle))
			{
				return Prefix.Equals(tagDirective.Prefix);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Handle.GetHashCode() ^ Prefix.GetHashCode();
		}

		public override string ToString()
		{
			return Handle + " => " + Prefix;
		}
	}
	internal abstract class Token
	{
		public Mark Start { get; }

		public Mark End { get; }

		protected Token([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
		{
			Start = start;
			End = end;
		}
	}
	internal sealed class Value : Token
	{
		public Value()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public Value([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class VersionDirective : Token
	{
		public Version Version { get; }

		public VersionDirective(Version version)
			: this(version, Mark.Empty, Mark.Empty)
		{
		}

		public VersionDirective(Version version, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Version = version;
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
		public override bool Equals(object obj)
		{
			if (obj is VersionDirective versionDirective)
			{
				return Version.Equals(versionDirective.Version);
			}
			return false;
		}

		public override int GetHashCode()
		{
			return Version.GetHashCode();
		}
	}
}
namespace YamlDotNet.Core.Events
{
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class AnchorAlias : ParsingEvent
	{
		internal override EventType Type => EventType.Alias;

		public AnchorName Value { get; }

		public AnchorAlias(AnchorName value, Mark start, Mark end)
			: base(ref start, ref end)
		{
			if (value.IsEmpty)
			{
				throw new YamlException(ref start, ref end, "Anchor value must not be empty.");
			}
			Value = value;
		}

		public AnchorAlias(AnchorName value)
			: this(value, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Alias [value = {Value}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class Comment : ParsingEvent
	{
		public string Value { get; }

		public bool IsInline { get; }

		internal override EventType Type => EventType.Comment;

		public Comment(string value, bool isInline)
			: this(value, isInline, Mark.Empty, Mark.Empty)
		{
		}

		public Comment(string value, bool isInline, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Value = value;
			IsInline = isInline;
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}

		public override string ToString()
		{
			return (IsInline ? "Inline" : "Block") + " Comment [" + Value + "]";
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class DocumentEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.DocumentEnd;

		public bool IsImplicit { get; }

		public DocumentEnd(bool isImplicit, Mark start, Mark end)
			: base(ref start, ref end)
		{
			IsImplicit = isImplicit;
		}

		public DocumentEnd(bool isImplicit)
			: this(isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Document end [isImplicit = {IsImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(2)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class DocumentStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.DocumentStart;

		public TagDirectiveCollection Tags { get; }

		public VersionDirective Version { get; }

		public bool IsImplicit { get; }

		public DocumentStart(VersionDirective version, TagDirectiveCollection tags, bool isImplicit, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Version = version;
			Tags = tags;
			IsImplicit = isImplicit;
		}

		public DocumentStart(VersionDirective version, TagDirectiveCollection tags, bool isImplicit)
			: this(version, tags, isImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public DocumentStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: this(null, null, isImplicit: true, start, end)
		{
		}

		public DocumentStart()
			: this(null, null, isImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public override string ToString()
		{
			return $"Document start [isImplicit = {IsImplicit}]";
		}

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum EventType
	{
		None,
		StreamStart,
		StreamEnd,
		DocumentStart,
		DocumentEnd,
		Alias,
		Scalar,
		SequenceStart,
		SequenceEnd,
		MappingStart,
		MappingEnd,
		Comment
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal interface IParsingEventVisitor
	{
		void Visit(AnchorAlias e);

		void Visit(StreamStart e);

		void Visit(StreamEnd e);

		void Visit(DocumentStart e);

		void Visit(DocumentEnd e);

		void Visit(Scalar e);

		void Visit(SequenceStart e);

		void Visit(SequenceEnd e);

		void Visit(MappingStart e);

		void Visit(MappingEnd e);

		void Visit(Comment e);
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal class MappingEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.MappingEnd;

		public MappingEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}

		public MappingEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Mapping end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class MappingStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.MappingStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public MappingStyle Style { get; }

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public MappingStart(AnchorName anchor, TagName tag, bool isImplicit, MappingStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public MappingStart()
			: this(AnchorName.Empty, TagName.Empty, isImplicit: true, MappingStyle.Any, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Mapping start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum MappingStyle
	{
		Any,
		Block,
		Flow
	}
	internal abstract class NodeEvent : ParsingEvent
	{
		public AnchorName Anchor { get; }

		public TagName Tag { get; }

		public abstract bool IsCanonical { get; }

		protected NodeEvent(AnchorName anchor, TagName tag, Mark start, Mark end)
			: base(ref start, ref end)
		{
			Anchor = anchor;
			Tag = tag;
		}

		protected NodeEvent(AnchorName anchor, TagName tag)
			: this(anchor, tag, Mark.Empty, Mark.Empty)
		{
		}
	}
	internal abstract class ParsingEvent
	{
		public virtual int NestingIncrease => 0;

		internal abstract EventType Type { get; }

		public Mark Start { get; }

		public Mark End { get; }

		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public abstract void Accept(IParsingEventVisitor visitor);

		internal ParsingEvent([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
		{
			Start = start;
			End = end;
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class Scalar : NodeEvent
	{
		internal override EventType Type => EventType.Scalar;

		public string Value { get; }

		public ScalarStyle Style { get; }

		public bool IsPlainImplicit { get; }

		public bool IsQuotedImplicit { get; }

		public override bool IsCanonical
		{
			get
			{
				if (!IsPlainImplicit)
				{
					return !IsQuotedImplicit;
				}
				return false;
			}
		}

		public bool IsKey { get; }

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit, Mark start, Mark end, bool isKey = false)
			: base(anchor, tag, start, end)
		{
			Value = value;
			Style = style;
			IsPlainImplicit = isPlainImplicit;
			IsQuotedImplicit = isQuotedImplicit;
			IsKey = isKey;
		}

		public Scalar(AnchorName anchor, TagName tag, string value, ScalarStyle style, bool isPlainImplicit, bool isQuotedImplicit)
			: this(anchor, tag, value, style, isPlainImplicit, isQuotedImplicit, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(string value)
			: this(AnchorName.Empty, TagName.Empty, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(TagName tag, string value)
			: this(AnchorName.Empty, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public Scalar(AnchorName anchor, TagName tag, string value)
			: this(anchor, tag, value, ScalarStyle.Any, isPlainImplicit: true, isQuotedImplicit: true, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Scalar [anchor = {base.Anchor}, tag = {base.Tag}, value = {Value}, style = {Style}, isPlainImplicit = {IsPlainImplicit}, isQuotedImplicit = {IsQuotedImplicit}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class SequenceEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.SequenceEnd;

		public SequenceEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}

		public SequenceEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Sequence end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class SequenceStart : NodeEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.SequenceStart;

		public bool IsImplicit { get; }

		public override bool IsCanonical => !IsImplicit;

		public SequenceStyle Style { get; }

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style, Mark start, Mark end)
			: base(anchor, tag, start, end)
		{
			IsImplicit = isImplicit;
			Style = style;
		}

		public SequenceStart(AnchorName anchor, TagName tag, bool isImplicit, SequenceStyle style)
			: this(anchor, tag, isImplicit, style, Mark.Empty, Mark.Empty)
		{
		}

		public override string ToString()
		{
			return $"Sequence start [anchor = {base.Anchor}, tag = {base.Tag}, isImplicit = {IsImplicit}, style = {Style}]";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	internal enum SequenceStyle
	{
		Any,
		Block,
		Flow
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	internal sealed class StreamEnd : ParsingEvent
	{
		public override int NestingIncrease => -1;

		internal override EventType Type => EventType.StreamEnd;

		public StreamEnd([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}

		public StreamEnd()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public override string ToString()
		{
			return "Stream end";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	internal sealed class StreamStart : ParsingEvent
	{
		public override int NestingIncrease => 1;

		internal override EventType Type => EventType.StreamStart;

		public StreamStart()
			: this(ref Mark.Empty, ref Mark.Empty)
		{
		}

		public StreamStart([In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark start, [In][<dda10819-09af-468b-b453-858f54a2b79b>IsReadOnly] ref Mark end)
			: base(ref start, ref end)
		{
		}

		public override string ToString()
		{
			return "Stream start";
		}

		public override void Accept(IParsingEventVisitor visitor)
		{
			visitor.Visit(this);
		}
	}
}
namespace System.Collections.Generic
{
	internal static class DeconstructionExtensions
	{
		[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
		public static void Deconstruct<[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TKey, [<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(2)] TValue>([<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(new byte[] { 0, 1, 1 })] this KeyValuePair<TKey, TValue> pair, out TKey key, out TValue value)
		{
			key = pair.Key;
			value = pair.Value;
		}
	}
}
namespace System.Diagnostics.CodeAnalysis
{
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	internal sealed class AllowNullAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter, Inherited = false)]
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	internal sealed class DisallowNullAttribute : Attribute
	{
	}
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Method, Inherited = false)]
	[DebuggerNonUserCode]
	internal sealed class DoesNotReturnAttribute : Attribute
	{
	}
	[ExcludeFromCodeCoverage]
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	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)]
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	internal sealed class MaybeNullAttribute : Attribute
	{
	}
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class MaybeNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public MaybeNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	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;
		}
	}
	[DebuggerNonUserCode]
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[ExcludeFromCodeCoverage]
	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
	{
	}
	[<0dc45880-19d9-434b-897d-f5b1ff6c0940>NullableContext(1)]
	[<f611d04d-bd24-4890-804f-05bc55fa4f32>Nullable(0)]
	[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;
		}
	}
	[DebuggerNonUserCode]
	[ExcludeFromCodeCoverage]
	[AttributeUsage(AttributeTargets.Parameter, Inherited = false)]
	internal sealed class NotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public NotNullWhenAttribute(bool returnValue)
		{
			ReturnValue = returnValue;
		}
	}
}
namespace System.IO.Compression
{
	internal static class Crc32Helper
	{
		private static readonly uint[] crcTable = new uint[256]
		{
			0u, 1996959894u, 3993919788u, 2567524794u, 124634137u, 1886057615u, 3915621685u, 2657392035u, 249268274u, 2044508324u,
			3772115230u, 2547177864u, 162941995u, 2125561021u, 3887607047u, 2428444049u, 498536548u, 1789927666u, 4089016648u, 2227061214u,
			450548861u, 1843258603u, 4107580753u, 2211677639u, 325883990u, 1684777152u, 4251122042u, 2321926636u, 335633487u, 1661365465u,
			4195302755u, 2366115317u, 997073096u, 1281953886u, 3579855332u, 2724688242u, 1006888145u, 1258607687u, 3524101629u, 2768942443u,
			901097722u, 1119000684u, 3686517206u, 2898065728u, 853044451u, 1172266101u, 3705015759u, 2882616665u, 651767980u, 1373503546u,
			3369554304u, 3218104598u, 565507253u, 1454621731u, 3485111705u, 3099436303u, 671266974u, 1594198024u, 3322730930u, 2970347812u,
			795835527u, 1483230225u, 3244367275u, 3060149565u, 1994146192u, 31158534u, 2563907772u, 4023717930u, 1907459465u, 112637215u,
			2680153253u, 3904427059u, 2013776290u, 251722036u, 2517215374u, 3775830040u, 2137656763u, 141376813u, 2439277719u, 3865271297u,
			1802195444u, 476864866u, 2238001368u, 4066508878u, 1812370925u, 453092731u, 2181625025u, 4111451223u, 1706088902u, 314042704u,
			2344532202u, 4240017532u, 1658658271u, 366619977u, 2362670323u, 4224994405u, 1303535960u, 984961486u, 2747007092u, 3569037538u,
			1256170817u, 1037604311u, 2765210733u, 3554079995u, 1131014506u, 879679996u, 2909243462u, 3663771856u, 1141124467u, 855842277u,
			2852801631u, 3708648649u, 1342533948u, 654459306u, 3188396048u, 3373015174u, 1466479909u, 544179635u, 3110523913u, 3462522015u,
			1591671054u, 702138776u, 2966460450u, 3352799412u, 1504918807u, 783551873u, 3082640443u, 3233442989u, 3988292384u, 2596254646u,
			62317068u, 1957810842u, 3939845945u, 2647816111u, 81470997u, 1943803523u, 3814918930u, 2489596804u, 225274430u, 2053790376u,
			3826175755u, 2466906013u, 167816743u, 2097651377u, 4027552580u, 2265490386u, 503444072u, 1762050814u, 4150417245u, 2154129355u,
			426522225u, 1852507879u, 4275313526u, 2312317920u, 282753626u, 1742555852u, 4189708143u, 2394877945u, 397917763u, 1622183637u,
			3604390888u, 2714866558u, 953729732u, 1340076626u, 3518719985u, 2797360999u, 1068828381u, 1219638859u, 3624741850u, 2936675148u,
			906185462u, 1090812512u, 3747672003u, 2825379669u, 829329135u, 1181335161u, 3412177804u, 3160834842u, 628085408u, 1382605366u,
			3423369109u, 3138078467u, 570562233u, 1426400815u, 3317316542u, 2998733608u, 733239954u, 1555261956u, 3268935591u, 3050360625u,
			752459403u, 1541320221u, 2607071920u, 3965973030u, 1969922972u, 40735498u, 2617837225u, 3943577151u, 1913087877u, 83908371u,
			2512341634u, 3803740692u, 2075208622u, 213261112u, 2463272603u, 3855990285u, 2094854071u, 198958881u, 2262029012u, 4057260610u,
			1759359992u, 534414190u, 2176718541u, 4139329115u, 1873836001u, 414664567u, 2282248934u, 4279200368u, 1711684554u, 285281116u,
			2405801727u, 4167216745u, 1634467795u, 376229701u, 2685067896u, 3608007406u, 1308918612u, 956543938u, 2808555105u, 3495958263u,
			1231636301u, 1047427035u, 2932959818u, 3654703836u, 1088359270u, 936918000u, 2847714899u, 3736837829u, 1202900863u, 817233897u,
			3183342108u, 3401237130u, 1404277552u, 615818150u, 3134207493u, 3453421203u, 1423857449u, 601450431u, 3009837614u, 3294710456u,
			1567103746u, 711928724u, 3020668471u, 3272380065u, 1510334235u, 755167117u
		};

		public static uint UpdateCrc32(uint crc32, byte[] buffer, int offset, int length)
		{
			crc32 ^= 0xFFFFFFFFu;
			while (--length >= 0)
			{
				crc32 = crcTable[(crc32 ^ buffer[offset++]) & 0xFF] ^ (crc32 >> 8);
			}
			crc32 ^= 0xFFFFFFFFu;
			return crc32;
		}
	}
	internal class WrappedStream : Stream
	{
		private readonly Stream _baseStream;

		private readonly EventHandler _onClosed;

		private bool _canRead;

		private bool _canWrite;

		private bool _canSeek;

		private bool _isDisposed;

		private readonly bool _closeBaseStream;

		public override long Length
		{
			get
			{
				ThrowIfDisposed();
				return _baseStream.Length;
			}
		}

		public override long Position
		{
			get
			{
				ThrowIfDisposed();
				return _baseStream.Position;
			}
			set
			{
				ThrowIfDisposed();
				ThrowIfCantSeek();
				_baseStream.Position = value;
			}
		}

		public override bool CanRead
		{
			get
			{
				if (_canRead)
				{
					return _baseStream.CanRead;
				}
				return false;
			}
		}

		public override bool CanSeek
		{
			get
			{
				if (_canSeek)
				{
					return _baseStream.CanSeek;
				}
				return false;
			}
		}

		public override bool CanWrite
		{
			get
			{
				if (_canWrite)
				{
					return _baseStream.CanWrite;
				}
				return false;
			}
		}

		internal WrappedStream(Stream baseStream, bool canRead, bool canWrite, bool canSeek, EventHandler onClosed)
			: this(baseStream, canRead, canWrite, canSeek, closeBaseStream: false, onClosed)
		{
		}

		internal WrappedStream(Stream baseStream, bool canRead, bool canWrite, bool canSeek, bool closeBaseStream, EventHandler onClosed)
		{
			_baseStream = baseStream;
			_onClosed = onClosed;
			_canRead = canRead;
			_canSeek = canSeek;
			_canWrite = canWrite;
			_isDisposed = false;
			_closeBaseStream = closeBaseStream;
		}

		internal WrappedStream(Stream baseStream, EventHandler onClosed)
			: this(baseStream, canRead: true, canWrite: true, canSeek: true, onClosed)
		{
		}

		private void ThrowIfDisposed()
		{
			if (_isDisposed)
			{
				throw new ObjectDisposedException(GetType().Name, Messages.HiddenStreamName);
			}
		}

		private void ThrowIfCantRead()
		{
			if (!CanWrite)
			{
				throw new NotSupportedException(Messages.WritingNotSupported);
			}
		}

		private void ThrowIfCantWrite()
		{
			if (!CanWrite)
			{
				throw new NotSupportedException(Messages.WritingNotSupported);
			}
		}

		private void ThrowIfCantSeek()
		{
			if (!CanSeek)
			{
				throw new NotSupportedException(Messages.SeekingNotSupported);
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			ThrowIfDisposed();
			ThrowIfCantRead();
			return _baseStream.Read(buffer, offset, count);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			ThrowIfDisposed();
			ThrowIfCantSeek();
			return _baseStream.Seek(offset, origin);
		}

		public override void SetLength(long value)
		{
			ThrowIfDisposed();
			ThrowIfCantSeek();
			ThrowIfCantWrite();
			_baseStream.SetLength(value);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			ThrowIfDisposed();
			ThrowIfCantWrite();
			_baseStream.Write(buffer, offset, count);
		}

		public override void Flush()
		{
			ThrowIfDisposed();
			ThrowIfCantWrite();
			_baseStream.Flush();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing && !_isDisposed)
			{
				if (_onClosed != null)
				{
					_onClosed(this, null);
				}
				if (_closeBaseStream)
				{
					_baseStream.Dispose();
				}
				_canRead = false;
				_canWrite = false;
				_canSeek = false;
				_isDisposed = true;
			}
			base.Dispose(disposing);
		}
	}
	internal class SubReadStream : Stream
	{
		private readonly long _startInSuperStream;

		private long _positionInSuperStream;

		private readonly long _endInSuperStream;

		private readonly Stream _superStream;

		private bool _canRead;

		private bool _isDisposed;

		public override long Length
		{
			get
			{
				ThrowIfDisposed();
				return _endInSuperStream - _startInSuperStream;
			}
		}

		public override long Position
		{
			get
			{
				ThrowIfDisposed();
				return _positionInSuperStream - _startInSuperStream;
			}
			set
			{
				ThrowIfDisposed();
				throw new NotSupportedException(Messages.SeekingNotSupported);
			}
		}

		public override bool CanRead
		{
			get
			{
				if (_superStream.CanRead)
				{
					return _canRead;
				}
				return false;
			}
		}

		public override bool CanSeek => false;

		public override bool CanWrite => false;

		public SubReadStream(Stream superStream, long startPosition, long maxLength)
		{
			_startInSuperStream = startPosition;
			_positionInSuperStream = startPosition;
			_endInSuperStream = startPosition + maxLength;
			_superStream = superStream;
			_canRead = true;
			_isDisposed = false;
		}

		private void ThrowIfDisposed()
		{
			if (_isDisposed)
			{
				throw new ObjectDisposedException(GetType().Name, Messages.HiddenStreamName);
			}
		}

		private void ThrowIfCantRead()
		{
			if (!CanRead)
			{
				throw new NotSupportedException(Messages.ReadingNotSupported);
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			int num = count;
			ThrowIfDisposed();
			ThrowIfCantRead();
			if (_superStream.Position != _positionInSuperStream)
			{
				_superStream.Seek(_positionInSuperStream, SeekOrigin.Begin);
			}
			if (_positionInSuperStream + count > _endInSuperStream)
			{
				count = (int)(_endInSuperStream - _positionInSuperStream);
			}
			int num2 = _superStream.Read(buffer, offset, count);
			_positionInSuperStream += num2;
			return num2;
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			ThrowIfDisposed();
			throw new NotSupportedException(Messages.SeekingNotSupported);
		}

		public override void SetLength(long value)
		{
			ThrowIfDisposed();
			throw new NotSupportedException(Messages.SetLengthRequiresSeekingAndWriting);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			ThrowIfDisposed();
			throw new NotSupportedException(Messages.WritingNotSupported);
		}

		public override void Flush()
		{
			ThrowIfDisposed();
			throw new NotSupportedException(Messages.WritingNotSupported);
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing && !_isDisposed)
			{
				_canRead = false;
				_isDisposed = true;
			}
			base.Dispose(disposing);
		}
	}
	internal class CheckSumAndSizeWriteStream : Stream
	{
		private readonly Stream _baseStream;

		private readonly Stream _baseBaseStream;

		private long _position;

		private uint _checksum;

		private readonly bool _leaveOpenOnClose;

		private bool _canWrite;

		private bool _isDisposed;

		private bool _everWritten;

		private long _initialPosition;

		private readonly Action<long, long, uint> _saveCrcAndSizes;

		public override long Length
		{
			get
			{
				ThrowIfDisposed();
				throw new NotSupportedException(Messages.SeekingNotSupported);
			}
		}

		public override long Position
		{
			get
			{
				ThrowIfDisposed();
				return _position;
			}
			set
			{
				ThrowIfDisposed();
				throw new NotSupportedException(Messages.SeekingNotSupported);
			}
		}

		public override bool CanRead => false;

		public override bool CanSeek => false;

		public override bool CanWrite => _canWrite;

		public CheckSumAndSizeWriteStream(Stream baseStream, Stream baseBaseStream, bool leaveOpenOnClose, Action<long, long, uint> saveCrcAndSizes)
		{
			_baseStream = baseStream;
			_baseBaseStream = baseBaseStream;
			_position = 0L;
			_checksum = 0u;
			_leaveOpenOnClose = leaveOpenOnClose;
			_canWrite = true;
			_isDisposed = false;
			_initialPosition = 0L;
			_saveCrcAndSizes = saveCrcAndSizes;
		}

		private void ThrowIfDisposed()
		{
			if (_isDisposed)
			{
				throw new ObjectDisposedException(GetType().Name, Messages.HiddenStreamName);
			}
		}

		public override int Read(byte[] buffer, int offset, int count)
		{
			ThrowIfDisposed();
			throw new NotSupportedException(Messages.ReadingNotSupported);
		}

		public override long Seek(long offset, SeekOrigin origin)
		{
			ThrowIfDisposed();
			throw new NotSupportedException(Messages.SeekingNotSupported);
		}

		public override void SetLength(long value)
		{
			ThrowIfDisposed();
			throw new NotSupportedException(Messages.SetLengthRequiresSeekingAndWriting);
		}

		public override void Write(byte[] buffer, int offset, int count)
		{
			if (buffer == null)
			{
				throw new ArgumentNullException("buffer");
			}
			if (offset < 0)
			{
				throw new ArgumentOutOfRangeException("offset", Messages.ArgumentNeedNonNegative);
			}
			if (count < 0)
			{
				throw new ArgumentOutOfRangeException("count", Messages.ArgumentNeedNonNegative);
			}
			if (buffer.Length - offset < count)
			{
				throw new ArgumentException(Messages.OffsetLengthInvalid);
			}
			ThrowIfDisposed();
			if (count != 0)
			{
				if (!_everWritten)
				{
					_initialPosition = _baseBaseStream.Position;
					_everWritten = true;
				}
				_checksum = System.IO.Compression.Crc32Helper.UpdateCrc32(_checksum, buffer, offset, count);
				_baseStream.Write(buffer, offset, count);
				_position += count;
			}
		}

		public override void Flush()
		{
			ThrowIfDisposed();
			_baseStream.Flush();
		}

		protected override void Dispose(bool disposing)
		{
			if (disposing && !_isDisposed)
			{
				if (!_everWritten)
				{
					_initialPosition = _baseBaseStream.Position;
				}
				if (!_leaveOpenOnClose)
				{
					_baseStream.Close();
				}
				if (_saveCrcAndSizes != null)
				{
					_saveCrcAndSizes(_initialPosition, Position, _checksum);
				}
				_isDisposed = true;
			}
			base.Dispose(disposing);
		}
	}
	[__DynamicallyInvokable]
	internal class ZipArchive : IDisposable
	{
		private Stream _archiveStream;

		private ZipArchiveEntry _archiveStreamOwner;

		private BinaryReader _archiveReader;

		private ZipArchiveMode _mode;

		private List<ZipArchiveEntry> _entries;

		private ReadOnlyCollection<ZipArchiveEntry> _entriesCollection;

		private Dictionary<string, ZipArchiveEntry> _entriesDictionary;

		private bool _readEntries;

		private bool _leaveOpen;

		private long _centralDirectoryStart;

		private bool _isDisposed;

		private uint _numberOfThisDisk;

		private long _expectedNumberOfEntries;

		private Stream _backingStream;

		private byte[] _archiveComment;

		private Encoding _entryNameEncoding;

		[__DynamicallyInvokable]
		public ReadOnlyCollection<ZipArchiveEntry> Entries
		{
			[__DynamicallyInvokable]
			get
			{
				if (_mode == ZipArchiveMode.Create)
				{
					throw new NotSupportedException(Messages.EntriesInCreateMode);
				}
				ThrowIfDisposed();
				EnsureCentralDirectoryRead();
				return _entriesCollection;
			}
		}

		[__DynamicallyInvokable]
		public ZipArchiveMode Mode
		{
			[__DynamicallyInvokable]
			get
			{
				return _mode;
			}
		}

		internal BinaryReader ArchiveReader => _archiveReader;

		internal Stream ArchiveStream => _archiveStream;

		internal uint NumberOfThisDisk => _numberOfThisDisk;

		internal Encoding EntryNameEncoding
		{
			get
			{
				return _entryNameEncoding;
			}
			private set
			{
				if (value != null && (value.Equals(Encoding.BigEndianUnicode) || value.Equals(Encoding.Unicode) || value.Equals(Encoding.UTF32) || value.Equals(Encoding.UTF7)))
				{
					throw new ArgumentException(Messages.EntryNameEncodingNotSupported, "entryNameEncoding");
				}
				_entryNameEncoding = value;
			}
		}

		[__DynamicallyInvokable]
		public ZipArchive(Stream stream)
			: this(stream, ZipArchiveMode.Read, leaveOpen: false, null)
		{
		}

		[__DynamicallyInvokable]
		public ZipArchive(Stream stream, ZipArchiveMode mode)
			: this(stream, mode, leaveOpen: false, null)
		{
		}

		[__DynamicallyInvokable]
		public ZipArchive(Stream stream, ZipArchiveMode mode, bool leaveOpen)
			: this(stream, mode, leaveOpen, null)
		{
		}

		[__DynamicallyInvokable]
		public ZipArchive(Stream stream, ZipArchiveMode mode, bool leaveOpen, Encoding entryNameEncoding)
		{
			if (stream == null)
			{
				throw new ArgumentNullException("stream");
			}
			EntryNameEncoding = entryNameEncoding;
			Init(stream, mode, leaveOpen);
		}

		[__DynamicallyInvokable]
		public ZipArchiveEntry CreateEntry(string entryName)
		{
			return DoCreateEntry(entryName, null);
		}

		[__DynamicallyInvokable]
		public ZipArchiveEntry CreateEntry(string entryName, CompressionLevel compressionLevel)
		{
			return DoCreateEntry(entryName, compressionLevel);
		}

		[__DynamicallyInvokable]
		protected virtual void Dispose(bool disposing)
		{
			if (!disposing || _isDisposed)
			{
				return;
			}
			ZipArchiveMode mode = _mode;
			if (mode != 0)
			{
				_ = mode - 1;
				_ = 1;
				try
				{
					WriteFile();
				}
				catch (InvalidDataException)
				{
					CloseStreams();
					_isDisposed = true;
					throw;
				}
			}
			CloseStreams();
			_isDisposed = true;
		}

		[__DynamicallyInvokable]
		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		[__DynamicallyInvokable]
		public ZipArchiveEntry GetEntry(string entryName)
		{
			if (entryName == null)
			{
				throw new ArgumentNullException("entryName");
			}
			if (_mode == ZipArchiveMode.Create)
			{
				throw new NotSupportedException(Messages.EntriesInCreateMode);
			}
			EnsureCentralDirectoryRead();
			_entriesDictionary.TryGetValue(entryName, out var value);
			return value;
		}

		private ZipArchiveEntry DoCreateEntry(string entryName, CompressionLevel? compressionLevel)
		{
			if (entryName == null)
			{
				throw new ArgumentNullException("entryName");
			}
			if (string.IsNullOrEmpty(entryName))
			{
				throw new ArgumentException(Messages.CannotBeEmpty, "entryName");
			}
			if (_mode == ZipArchiveMode.Read)
			{
				throw new NotSupportedException(Messages.CreateInReadMode);
			}
			ThrowIfDisposed();
			ZipArchiveEntry zipArchiveEntry = (compressionLevel.HasValue ? new ZipArchiveEntry(this, entryName, compressionLevel.Value) : new ZipArchiveEntry(this, entryName));
			AddEntry(zipArchiveEntry);
			return zipArchiveEntry;
		}

		internal void AcquireArchiveStream(ZipArchiveEntry entry)
		{
			if (_archiveStreamOwner != null)
			{
				if (_archiveStreamOwner.EverOpenedForWrite)
				{
					throw new IOException(Messages.CreateModeCreateEntryWhileOpen);
				}
				_archiveStreamOwner.WriteAndFinishLocalEntry();
			}
			_archiveStreamOwner = entry;
		}

		private void AddEntry(ZipArchiveEntry entry)
		{
			_entries.Add(entry);
			string fullName = entry.FullName;
			if (!_entriesDictionary.ContainsKey(fullName))
			{
				_entriesDictionary.Add(fullName, entry);
			}
		}

		internal bool IsStillArchiveStreamOwner(ZipArchiveEntry entry)
		{
			return _archiveStreamOwner == entry;
		}

		internal void ReleaseArchiveStream(ZipArchiveEntry entry)
		{
			_archiveStreamOwner = null;
		}

		internal void RemoveEntry(ZipArchiveEntry entry)
		{
			_entries.Remove(entry);
			_entriesDictionary.Remove(entry.FullName);
		}

		internal void ThrowIfDisposed()
		{
			if (_isDisposed)
			{
				throw new ObjectDisposedException(GetType().Name);
			}
		}

		private void CloseStreams()
		{
			if (!_leaveOpen)
			{
				_archiveStream.Close();
				if (_backingStream != null)
				{
					_backingStream.Close();
				}
				if (_archiveReader != null)
				{
					_archiveReader.Close();
				}
			}
			else if (_backingStream != null)
			{
				_archiveStream.Close();
			}
		}

		private void EnsureCentralDirectoryRead()
		{
			if (!_readEntries)
			{
				ReadCentralDirectory();
				_readEntries = true;
			}
		}

		private void Init(Stream stream, ZipArchiveMode mode, bool leaveOpen)
		{
			Stream stream2 = null;
			try
			{
				_backingStream = null;
				switch (mode)
				{
				case ZipArchiveMode.Create:
					if (!stream.CanWrite)
					{
						throw new ArgumentException(Messages.CreateModeCapabilities);
					}
					break;
				case ZipArchiveMode.Read:
					if (!stream.CanRead)
					{
						throw new ArgumentException(Messages.ReadModeCapabilities);
					}
					if (!stream.CanSeek)
					{
						_backingStream = stream;
						stream2 = (stream = new MemoryStream());
						_backingStream.CopyTo(stream);
						stream.Seek(0L, SeekOrigin.Begin);
					}
					break;
				case ZipArchiveMode.Update:
					if (!stream.CanRead || !stream.CanWrite || !stream.CanSeek)
					{
						throw new ArgumentException(Messages.UpdateModeCapabilities);
					}
					break;
				default:
					throw new ArgumentOutOfRangeException("mode");
				}
				_mode = mode;
				_archiveStream = stream;
				_archiveStreamOwner = null;
				if (mode == ZipArchiveMode.Create)
				{
					_archiveReader = null;
				}
				else
				{
					_archiveReader = new BinaryReader(stream);
				}
				_entries = new List<ZipArchiveEntry>();
				_entriesCollection = new ReadOnlyCollection<ZipArchiveEntry>(_entries);
				_entriesDictionary = new Dictionary<string, ZipArchiveEntry>();
				_readEntries = false;
				_leaveOpen = leaveOpen;
				_centralDirectoryStart = 0L;
				_isDisposed = false;
				_numberOfThisDisk = 0u;
				_archiveComment = null;
				switch (mode)
				{
				case ZipArchiveMode.Create:
					_readEntries = true;
					return;
				case ZipArchiveMode.Read:
					ReadEndOfCentralDirectory();
					return;
				}
				if (_archiveStream.Length == 0L)
				{
					_readEntries = true;
					return;
				}
				ReadEndOfCentralDirectory();
				EnsureCentralDirectoryRead();
				foreach (ZipArchiveEntry entry in _entries)
				{
					entry.ThrowIfNotOpenable(needToUncompress: false, needToLoadIntoMemory: true);
				}
			}
			catch
			{
				stream2?.Close();
				throw;
			}
		}

		private void ReadCentralDirectory()
		{
			try
			{
				_archiveStream.Seek(_centralDirectoryStart, SeekOrigin.Begin);
				long num = 0L;
				bool saveExtraFieldsAndComments = Mode == ZipArchiveMode.Update;
				System.IO.Compression.ZipCentralDirectoryFileHeader header;
				while (System.IO.Compression.ZipCentralDirectoryFileHeader.TryReadBlock(_archiveReader, saveExtraFieldsAndComments, out header))
				{
					AddEntry(new ZipArchiveEntry(this, header));
					num++;
				}
				if (num != _expectedNumberOfEntries)
				{
					throw new InvalidDataException(Messages.NumEntriesWrong);
				}
			}
			catch (EndOfStreamException innerException)
			{
				throw new InvalidDataException(Messages.CentralDirectoryInvalid, innerException);
			}
		}

		private void ReadEndOfCentralDirectory()
		{
			try
			{
				_archiveStream.Seek(-18L, SeekOrigin.End);
				if (!System.IO.Compression.ZipHelper.SeekBackwardsToSignature(_archiveStream, 101010256u))
				{
					throw new InvalidDataException(Messages.EOCDNotFound);
				}
				long position = _archiveStream.Position;
				System.IO.Compression.ZipEndOfCentralDirectoryBlock eocdBlock;
				bool flag = System.IO.Compression.ZipEndOfCentralDirectoryBlock.TryReadBlock(_archiveReader, out eocdBlock);
				if (eocdBlock.NumberOfThisDisk != eocdBlock.NumberOfTheDiskWithTheStartOfTheCentralDirectory)
				{
					throw new InvalidDataException(Messages.SplitSpanned);
				}
				_numberOfThisDisk = eocdBlock.NumberOfThisDisk;
				_centralDirectoryStart = eocdBlock.OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber;
				if (eocdBlock.NumberOfEntriesInTheCentralDirectory != eocdBlock.NumberOfEntriesInTheCentralDirectoryOnThisDisk)
				{
					throw new InvalidDataException(Messages.SplitSpanned);
				}
				_expectedNumberOfEntries = eocdBlock.NumberOfEntriesInTheCentralDirectory;
				if (_mode == ZipArchiveMode.Update)
				{
					_archiveComment = eocdBlock.ArchiveComment;
				}
				if (eocdBlock.NumberOfThisDisk == ushort.MaxValue || eocdBlock.OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber == uint.MaxValue || eocdBlock.NumberOfEntriesInTheCentralDirectory == ushort.MaxValue)
				{
					_archiveStream.Seek(position - 16, SeekOrigin.Begin);
					if (System.IO.Compression.ZipHelper.SeekBackwardsToSignature(_archiveStream, 117853008u))
					{
						System.IO.Compression.Zip64EndOfCentralDirectoryLocator zip64EOCDLocator;
						bool flag2 = System.IO.Compression.Zip64EndOfCentralDirectoryLocator.TryReadBlock(_archiveReader, out zip64EOCDLocator);
						if (zip64EOCDLocator.OffsetOfZip64EOCD > long.MaxValue)
						{
							throw new InvalidDataException(Messages.FieldTooBigOffsetToZip64EOCD);
						}
						long offsetOfZip64EOCD = (long)zip64EOCDLocator.OffsetOfZip64EOCD;
						_archiveStream.Seek(offsetOfZip64EOCD, SeekOrigin.Begin);
						if (!System.IO.Compression.Zip64EndOfCentralDirectoryRecord.TryReadBlock(_archiveReader, out var zip64EOCDRecord))
						{
							throw new InvalidDataException(Messages.Zip64EOCDNotWhereExpected);
						}
						_numberOfThisDisk = zip64EOCDRecord.NumberOfThisDisk;
						if (zip64EOCDRecord.NumberOfEntriesTotal > long.MaxValue)
						{
							throw new InvalidDataException(Messages.FieldTooBigNumEntries);
						}
						if (zip64EOCDRecord.OffsetOfCentralDirectory > long.MaxValue)
						{
							throw new InvalidDataException(Messages.FieldTooBigOffsetToCD);
						}
						if (zip64EOCDRecord.NumberOfEntriesTotal != zip64EOCDRecord.NumberOfEntriesOnThisDisk)
						{
							throw new InvalidDataException(Messages.SplitSpanned);
						}
						_expectedNumberOfEntries = (long)zip64EOCDRecord.NumberOfEntriesTotal;
						_centralDirectoryStart = (long)zip64EOCDRecord.OffsetOfCentralDirectory;
					}
				}
				if (_centralDirectoryStart > _archiveStream.Length)
				{
					throw new InvalidDataException(Messages.FieldTooBigOffsetToCD);
				}
			}
			catch (EndOfStreamException innerException)
			{
				throw new InvalidDataException(Messages.CDCorrupt, innerException);
			}
			catch (IOException innerException2)
			{
				throw new InvalidDataException(Messages.CDCorrupt, innerException2);
			}
		}

		private void WriteFile()
		{
			if (_mode == ZipArchiveMode.Update)
			{
				List<ZipArchiveEntry> list = new List<ZipArchiveEntry>();
				foreach (ZipArchiveEntry entry in _entries)
				{
					if (!entry.LoadLocalHeaderExtraFieldAndCompressedBytesIfNeeded())
					{
						list.Add(entry);
					}
				}
				foreach (ZipArchiveEntry item in list)
				{
					item.Delete();
				}
				_archiveStream.Seek(0L, SeekOrigin.Begin);
				_archiveStream.SetLength(0L);
			}
			foreach (ZipArchiveEntry entry2 in _entries)
			{
				entry2.WriteAndFinishLocalEntry();
			}
			long position = _archiveStream.Position;
			foreach (ZipArchiveEntry entry3 in _entries)
			{
				entry3.WriteCentralDirectoryFileHeader();
			}
			long sizeOfCentralDirectory = _archiveStream.Position - position;
			WriteArchiveEpilogue(position, sizeOfCentralDirectory);
		}

		private void WriteArchiveEpilogue(long startOfCentralDirectory, long sizeOfCentralDirectory)
		{
			bool flag = false;
			if (startOfCentralDirectory >= uint.MaxValue || sizeOfCentralDirectory >= uint.MaxValue || _entries.Count >= 65535)
			{
				flag = true;
			}
			if (flag)
			{
				long position = _archiveStream.Position;
				System.IO.Compression.Zip64EndOfCentralDirectoryRecord.WriteBlock(_archiveStream, _entries.Count, startOfCentralDirectory, sizeOfCentralDirectory);
				System.IO.Compression.Zip64EndOfCentralDirectoryLocator.WriteBlock(_archiveStream, position);
			}
			System.IO.Compression.ZipEndOfCentralDirectoryBlock.WriteBlock(_archiveStream, _entries.Count, startOfCentralDirectory, sizeOfCentralDirectory, _archiveComment);
		}
	}
	[__DynamicallyInvokable]
	internal class ZipArchiveEntry
	{
		private class DirectToArchiveWriterStream : Stream
		{
			private long _position;

			private System.IO.Compression.CheckSumAndSizeWriteStream _crcSizeStream;

			private bool _everWritten;

			private bool _isDisposed;

			private ZipArchiveEntry _entry;

			private bool _usedZip64inLH;

			private bool _canWrite;

			public override long Length
			{
				get
				{
					ThrowIfDisposed();
					throw new NotSupportedException(Messages.SeekingNotSupported);
				}
			}

			public override long Position
			{
				get
				{
					ThrowIfDisposed();
					return _position;
				}
				set
				{
					ThrowIfDisposed();
					throw new NotSupportedException(Messages.SeekingNotSupported);
				}
			}

			public override bool CanRead => false;

			public override bool CanSeek => false;

			public override bool CanWrite => _canWrite;

			public DirectToArchiveWriterStream(System.IO.Compression.CheckSumAndSizeWriteStream crcSizeStream, ZipArchiveEntry entry)
			{
				_position = 0L;
				_crcSizeStream = crcSizeStream;
				_everWritten = false;
				_isDisposed = false;
				_entry = entry;
				_usedZip64inLH = false;
				_canWrite = true;
			}

			private void ThrowIfDisposed()
			{
				if (_isDisposed)
				{
					throw new ObjectDisposedException(GetType().Name, Messages.HiddenStreamName);
				}
			}

			public override int Read(byte[] buffer, int offset, int count)
			{
				ThrowIfDisposed();
				throw new NotSupportedException(Messages.ReadingNotSupported);
			}

			public override long Seek(long offset, SeekOrigin origin)
			{
				ThrowIfDisposed();
				throw new NotSupportedException(Messages.SeekingNotSupported);
			}

			public override void SetLength(long value)
			{
				ThrowIfDisposed();
				throw new NotSupportedException(Messages.SetLengthRequiresSeekingAndWriting);
			}

			public override void Write(byte[] buffer, int offset, int count)
			{
				if (buffer == null)
				{
					throw new ArgumentNullException("buffer");
				}
				if (offset < 0)
				{
					throw new ArgumentOutOfRangeException("offset", Messages.ArgumentNeedNonNegative);
				}
				if (count < 0)
				{
					throw new ArgumentOutOfRangeException("count", Messages.ArgumentNeedNonNegative);
				}
				if (buffer.Length - offset < count)
				{
					throw new ArgumentException(Messages.OffsetLengthInvalid);
				}
				ThrowIfDisposed();
				if (count != 0)
				{
					if (!_everWritten)
					{
						_everWritten = true;
						_usedZip64inLH = _entry.WriteLocalFileHeader(isEmptyFile: false);
					}
					_crcSizeStream.Write(buffer, offset, count);
					_position += count;
				}
			}

			public override void Flush()
			{
				ThrowIfDisposed();
				_crcSizeStream.Flush();
			}

			protected override void Dispose(bool disposing)
			{
				if (disposing && !_isDisposed)
				{
					_crcSizeStream.Close();
					if (!_everWritten)
					{
						_entry.WriteLocalFileHeader(isEmptyFile: true);
					}
					else if (_entry._archive.ArchiveStream.CanSeek)
					{
						_entry.WriteCrcAndSizesInLocalHeader(_usedZip64inLH);
					}
					else
					{
						_entry.WriteDataDescriptor();
					}
					_canWrite = false;
					_isDisposed = true;
				}
				base.Dispose(disposing);
			}
		}

		[Flags]
		private enum BitFlagValues : ushort
		{
			DataDescriptor = 8,
			UnicodeFileName = 0x800
		}

		private enum CompressionMethodValues : ushort
		{
			Stored = 0,
			Deflate = 8
		}

		private enum OpenableValues
		{
			Openable,
			FileNonExistent,
			FileTooLarge
		}

		private const ushort DefaultVersionToExtract = 10;

		private ZipArchive _archive;

		private readonly bool _originallyInArchive;

		private readonly int _diskNumberStart;

		private System.IO.Compression.ZipVersionNeededValues _versionToExtract;

		private BitFlagValues _generalPurposeBitFlag;

		private CompressionMethodValues _storedCompressionMethod;

		private DateTimeOffset _lastModified;

		private long _compressedSize;

		private long _uncompressedSize;

		private long _offsetOfLocalHeader;

		private long? _storedOffsetOfCompressedData;

		private uint _crc32;

		private byte[] _compressedBytes;

		private MemoryStream _storedUncompressedData;

		private bool _currentlyOpenForWrite;

		private bool _everOpenedForWrite;

		private Stream _outstandingWriteStream;

		private uint _externalFileAttr;

		private string _storedEntryName;

		private byte[] _storedEntryNameBytes;

		private List<System.IO.Compression.ZipGenericExtraField> _cdUnknownExtraFields;

		private List<System.IO.Compression.ZipGenericExtraField> _lhUnknownExtraFields;

		private byte[] _fileComment;

		private CompressionLevel? _compressionLevel;

		[__DynamicallyInvokable]
		public ZipArchive Archive
		{
			[__DynamicallyInvokable]
			get
			{
				return _archive;
			}
		}

		[__DynamicallyInvokable]
		public long CompressedLength
		{
			[__DynamicallyInvokable]
			get
			{
				if (_everOpenedForWrite)
				{
					throw new InvalidOperationException(Messages.LengthAfterWrite);
				}
				return _compressedSize;
			}
		}

		public int ExternalAttributes
		{
			get
			{
				return (int)_externalFileAttr;
			}
			set
			{
				ThrowIfInvalidArchive();
				_externalFileAttr = (uint)value;
			}
		}

		[__DynamicallyInvokable]
		public string FullName
		{
			[__DynamicallyInvokable]
			get
			{
				return _storedEntryName;
			}
			private set
			{
				if (value == null)
				{
					throw new ArgumentNullException("FullName");
				}
				_storedEntryNameBytes = EncodeEntryName(value, out var isUTF);
				_storedEntryName = value;
				if (isUTF)
				{
					_generalPurposeBitFlag |= BitFlagValues.UnicodeFileName;
				}
				else
				{
					_generalPurposeBitFlag &= ~BitFlagValues.UnicodeFileName;
				}
				if (System.IO.Compression.ZipHelper.EndsWithDirChar(value))
				{
					VersionToExtractAtLeast(System.IO.Compression.ZipVersionNeededValues.ExplicitDirectory);
				}
			}
		}

		[__DynamicallyInvokable]
		public DateTimeOffset LastWriteTime
		{
			[__DynamicallyInvokable]
			get
			{
				return _lastModified;
			}
			[__DynamicallyInvokable]
			set
			{
				ThrowIfInvalidArchive();
				if (_archive.Mode == ZipArchiveMode.Read)
				{
					throw new NotSupportedException(Messages.ReadOnlyArchive);
				}
				if (_archive.Mode == ZipArchiveMode.Create && _everOpenedForWrite)
				{
					throw new IOException(Messages.FrozenAfterWrite);
				}
				if (value.DateTime.Year < 1980 || value.DateTime.Year > 2107)
				{
					throw new ArgumentOutOfRangeException("value", Messages.DateTimeOutOfRange);
				}
				_lastModified = value;
			}
		}

		[__DynamicallyInvokable]
		public long Length
		{
			[__DynamicallyInvokable]
			get
			{
				if (_everOpenedForWrite)
				{
					throw new InvalidOperationException(Messages.LengthAfterWrite);
				}
				return _uncompressedSize;
			}
		}

		[__DynamicallyInvokable]
		public string Name
		{
			[__DynamicallyInvokable]
			get
			{
				return Path.GetFileName(FullName);
			}
		}

		internal bool EverOpenedForWrite => _everOpenedForWrite;

		private long OffsetOfCompressedData
		{
			get
			{
				if (!_storedOffsetOfCompressedData.HasValue)
				{
					_archive.ArchiveStream.Seek(_offsetOfLocalHeader, SeekOrigin.Begin);
					if (!System.IO.Compression.ZipLocalFileHeader.TrySkipBlock(_archive.ArchiveReader))
					{
						throw new InvalidDataException(Messages.LocalFileHeaderCorrupt);
					}
					_storedOffsetOfCompressedData = _archive.ArchiveStream.Position;
				}
				return _storedOffsetOfCompressedData.Value;
			}
		}

		private MemoryStream UncompressedData
		{
			get
			{
				if (_storedUncompressedData == null)
				{
					_storedUncompressedData = new MemoryStream((int)_uncompressedSize);
					if (_originallyInArchive)
					{
						using Stream stream = OpenInReadMode(checkOpenable: false);
						try
						{
							stream.CopyTo(_storedUncompressedData);
						}
						catch (InvalidDataException)
						{
							_storedUncompressedData.Dispose();
							_storedUncompressedData = null;
							_currentlyOpenForWrite = false;
							_everOpenedForWrite = false;
							throw;
						}
					}
					CompressionMethod = CompressionMethodValues.Deflate;
				}
				return _storedUncompressedData;
			}
		}

		private CompressionMethodValues CompressionMethod
		{
			get
			{
				return _storedCompressionMethod;
			}
			set
			{
				if (value == CompressionMethodValues.Deflate)
				{
					VersionToExtractAtLeast(System.IO.Compression.ZipVersionNeededValues.ExplicitDirectory);
				}
				_storedCompressionMethod = value;
			}
		}

		internal ZipArchiveEntry(ZipArchive archive, System.IO.Compression.ZipCentralDirectoryFileHeader cd, CompressionLevel compressionLevel)
			: this(archive, cd)
		{
			_compressionLevel = compressionLevel;
		}

		internal ZipArchiveEntry(ZipArchive archive, System.IO.Compression.ZipCentralDirectoryFileHeader cd)
		{
			_archive = archive;
			_originallyInArchive = true;
			_diskNumberStart = cd.DiskNumberStart;
			_versionToExtract = (System.IO.Compression.ZipVersionNeededValues)cd.VersionNeededToExtract;
			_generalPurposeBitFlag = (BitFlagValues)cd.GeneralPurposeBitFlag;
			CompressionMethod = (CompressionMethodValues)cd.CompressionMethod;
			_lastModified = new DateTimeOffset(System.IO.Compression.ZipHelper.DosTimeToDateTime(cd.LastModified));
			_compressedSize = cd.CompressedSize;
			_uncompressedSize = cd.UncompressedSize;
			_externalFileAttr = cd.ExternalFileAttributes;
			_offsetOfLocalHeader = cd.RelativeOffsetOfLocalHeader;
			_storedOffsetOfCompressedData = null;
			_crc32 = cd.Crc32;
			_compressedBytes = null;
			_storedUncompressedData = null;
			_currentlyOpenForWrite = false;
			_everOpenedForWrite = false;
			_outstandingWriteStream = null;
			FullName = DecodeEntryName(cd.Filename);
			_lhUnknownExtraFields = null;
			_cdUnknownExtraFields = cd.ExtraFields;
			_fileComment = cd.FileComment;
			_compressionLevel = null;
		}

		internal ZipArchiveEntry(ZipArchive archive, string entryName, CompressionLevel compressionLevel)
			: this(archive, entryName)
		{
			_compressionLevel = compressionLevel;
		}

		internal ZipArchiveEntry(ZipArchive archive, string entryName)
		{
			_archive = archive;
			_originallyInArchive = false;
			_diskNumberStart = 0;
			_versionToExtract = System.IO.Compression.ZipVersionNeededValues.Default;
			_generalPurposeBitFlag = (BitFlagValues)0;
			CompressionMethod = CompressionMethodValues.Deflate;
			_lastModified = DateTimeOffset.Now;
			_compressedSize = 0L;
			_uncompressedSize = 0L;
			_externalFileAttr = 0u;
			_offsetOfLocalHeader = 0L;
			_storedOffsetOfCompressedData = null;
			_crc32 = 0u;
			_compressedBytes = null;
			_storedUncompressedData = null;
			_currentlyOpenForWrite = false;
			_everOpenedForWrite = false;
			_outstandingWriteStream = null;
			FullName = entryName;
			_cdUnknownExtraFields = null;
			_lhUnknownExtraFields = null;
			_fileComment = null;
			_compressionLevel = null;
			if (_storedEntryNameBytes.Length > 65535)
			{
				throw new ArgumentException(Messages.EntryNamesTooLong);
			}
			if (_archive.Mode == ZipArchiveMode.Create)
			{
				_archive.AcquireArchiveStream(this);
			}
		}

		[__DynamicallyInvokable]
		public void Delete()
		{
			if (_archive != null)
			{
				if (_currentlyOpenForWrite)
				{
					throw new IOException(Messages.DeleteOpenEntry);
				}
				if (_archive.Mode != ZipArchiveMode.Update)
				{
					throw new NotSupportedException(Messages.DeleteOnlyInUpdate);
				}
				_archive.ThrowIfDisposed();
				_archive.RemoveEntry(this);
				_archive = null;
				UnloadStreams();
			}
		}

		[__DynamicallyInvokable]
		public Stream Open()
		{
			ThrowIfInvalidArchive();
			return _archive.Mode switch
			{
				ZipArchiveMode.Read => OpenInReadMode(checkOpenable: true), 
				ZipArchiveMode.Create => OpenInWriteMode(), 
				_ => OpenInUpdateMode(), 
			};
		}

		[__DynamicallyInvokable]
		public override string ToString()
		{
			return FullName;
		}

		private string DecodeEntryName(byte[] entryNameBytes)
		{
			Encoding encoding = (((_generalPurposeBitFlag & BitFlagValues.UnicodeFileName) != 0) ? Encoding.UTF8 : ((_archive == null) ? Encoding.GetEncoding(0) : (_archive.EntryNameEncoding ?? Encoding.GetEncoding(0))));
			return new string(encoding.GetChars(entryNameBytes));
		}

		private byte[] EncodeEntryName(string entryName, out bool isUTF8)
		{
			Encoding encoding = ((_archive == null || _archive.EntryNameEncoding == null) ? (System.IO.Compression.ZipHelper.RequiresUnicode(entryName) ? Encoding.UTF8 : Encoding.GetEncoding(0)) : _archive.EntryNameEncoding);
			isUTF8 = encoding is UTF8Encoding && encoding.Equals(Encoding.UTF8);
			return encoding.GetBytes(entryName);
		}

		internal void WriteAndFinishLocalEntry()
		{
			CloseStreams();
			WriteLocalFileHeaderAndDataIfNeeded();
			UnloadStreams();
		}

		internal void WriteCentralDirectoryFileHeader()
		{
			BinaryWriter binaryWriter = new BinaryWriter(_archive.ArchiveStream);
			System.IO.Compression.Zip64ExtraField zip64ExtraField = default(System.IO.Compression.Zip64ExtraField);
			bool flag = false;
			uint value;
			uint value2;
			if (SizesTooLarge())
			{
				flag = true;
				value = uint.MaxValue;
				value2 = uint.MaxValue;
				zip64ExtraField.CompressedSize = _compressedSize;
				zip64ExtraField.UncompressedSize = _uncompressedSize;
			}
			else
			{
				value = (uint)_compressedSize;
				value2 = (uint)_uncompressedSize;
			}
			uint value3;
			if (_offsetOfLocalHeader > uint.MaxValue)
			{
				flag = true;
				value3 = uint.MaxValue;
				zip64ExtraField.LocalHeaderOffset = _offsetOfLocalHeader;
			}
			else
			{
				value3 = (uint)_offsetOfLocalHeader;
			}
			if (flag)
			{
				VersionToExtractAtLeast(System.IO.Compression.ZipVersionNeededValues.Zip64);
			}
			int num = (flag ? zip64ExtraField.TotalSize : 0) + ((_cdUnknownExtraFields != null) ? System.IO.Compression.ZipGenericExtraField.TotalSize(_cdUnknownExtraFields) : 0);
			ushort value4;
			if (num > 65535)
			{
				value4 = (ushort)(flag ? zip64ExtraField.TotalSize : 0);
				_cdUnknownExtraFields = null;
			}
			else
			{
				value4 = (ushort)num;
			}
			binaryWriter.Write(33639248u);
			binaryWriter.Write((ushort)_versionToExtract);
			binaryWriter.Write((ushort)_versionToExtract);
			binaryWriter.Write((ushort)_generalPurposeBitFlag);
			binaryWriter.Write((ushort)CompressionMethod);
			binaryWriter.Write(System.IO.Compression.ZipHelper.DateTimeToDosTime(_lastModified.DateTime));
			binaryWriter.Write(_crc32);
			binaryWriter.Write(value);
			binaryWriter.Write(value2);
			binaryWriter.Write((ushort)_storedEntryNameBytes.Length);
			binaryWriter.Write(value4);
			binaryWriter.Write((ushort)((_fileComment != null) ? ((ushort)_fileComment.Length) : 0));
			binaryWriter.Write((ushort)0);
			binaryWriter.Write((ushort)0);
			binaryWriter.Write(_externalFileAttr);
			binaryWriter.Write(value3);
			binaryWriter.Write(_storedEntryNameBytes);
			if (flag)
			{
				zip64ExtraField.WriteBlock(_archive.ArchiveStream);
			}
			if (_cdUnknownExtraFields != null)
			{
				System.IO.Compression.ZipGenericExtraField.WriteAllBlocks(_cdUnknownExtraFields, _archive.ArchiveStream);
			}
			if (_fileComment != null)
			{
				binaryWriter.Write(_fileComment);
			}
		}

		internal bool LoadLocalHeaderExtraFieldAndCompressedBytesIfNeeded()
		{
			if (_originallyInArchive)
			{
				_archive.ArchiveStream.Seek(_offsetOfLocalHeader, SeekOrigin.Begin);
				_lhUnknownExtraFields = System.IO.Compression.ZipLocalFileHeader.GetExtraFields(_archive.ArchiveReader);
			}
			if (!_everOpenedForWrite && _originallyInArchive)
			{
				_compressedBytes = new byte[_compressedSize];
				_archive.ArchiveStream.Seek(OffsetOfCompressedData, SeekOrigin.Begin);
				System.IO.Compression.ZipHelper.ReadBytes(_archive.ArchiveStream, _compressedBytes, (int)_compressedSize);
			}
			return true;
		}

		internal void ThrowIfNotOpenable(bool needToUncompress, bool needToLoadIntoMemory)
		{
			if (!IsOpenable(needToUncompress, needToLoadIntoMemory, out var message))
			{
				throw new InvalidDataException(message);
			}
		}

		private System.IO.Compression.CheckSumAndSizeWriteStream GetDataCompressor(Stream backingStream, bool leaveBackingStreamOpen, EventHandler onClose)
		{
			Stream baseStream = (_compressionLevel.HasValue ? new DeflateStream(backingStream, _compressionLevel.Value, leaveBackingStreamOpen) : new DeflateStream(backingStream, CompressionMode.Compress, leaveBackingStreamOpen));
			bool flag = true;
			bool leaveOpenOnClose = leaveBackingStreamOpen && !flag;
			return new System.IO.Compression.CheckSumAndSizeWriteStream(baseStream, backingStream, leaveOpenOnClose, delegate(long initialPosition, long currentPosition, uint checkSum)
			{
				_crc32 = checkSum;
				_uncompressedSize = currentPosition;
				_compressedSize = backingStream.Position - initialPosition;
				if (onClose != null)
				{
					onClose(this, EventArgs.Empty);
				}
			});
		}

		private Stream GetDataDecompressor(Stream compressedStreamToRead)
		{
			Stream stream = null;
			CompressionMethodValues compressionMethod = CompressionMethod;
			if (compressionMethod != 0 && compressionMethod == CompressionMethodValues.Deflate)
			{
				return new DeflateStream(compressedStreamToRead, CompressionMode.Decompress);
			}
			return compressedStreamToRead;
		}

		private Stream OpenInReadMode(bool checkOpenable)
		{
			if (checkOpenable)
			{
				ThrowIfNotOpenable(needToUncompress: true, needToLoadIntoMemory: false);
			}
			Stream compressedStreamToRead = new System.IO.Compression.SubReadStream(_archive.ArchiveStream, OffsetOfCompressedData, _compressedSize);
			return GetDataDecompressor(compressedStreamToRead);
		}

		private Stream OpenInWriteMode()
		{
			if (_everOpenedForWrite)
			{
				throw new IOException(Messages.CreateModeWriteOnceAndOneEntryAtATime);
			}
			_everOpenedForWrite = true;
			System.IO.Compression.CheckSumAndSizeWriteStream dataCompressor = GetDataCompressor(_archive.ArchiveStream, leaveBackingStreamOpen: true, delegate
			{
				_archive.ReleaseArchiveStream(this);
				_outstandingWriteStream = null;
			});
			_outstandingWriteStream = new DirectToArchiveWriterStream(dataCompressor, this);
			return new System.IO.Compression.WrappedStream(_outstandingWriteStream, delegate
			{
				_outstandingWriteStream.Close();
			});
		}

		private Stream OpenInUpdateMode()
		{
			if (_currentlyOpenForWrite)
			{
				throw new IOException(Messages.UpdateModeOneStream);
			}
			ThrowIfNotOpenable(needToUncompress: true, needToLoadIntoMemory: true);
			_everOpenedForWrite = true;
			_currentlyOpenForWrite = true;
			UncompressedData.Seek(0L, SeekOrigin.Begin);
			return new System.IO.Compression.WrappedStream(UncompressedData, delegate
			{
				_currentlyOpenForWrite = false;
			});
		}

		private bool IsOpenable(bool needToUncompress, bool needToLoadIntoMemory, out string message)
		{
			message = null;
			if (_originallyInArchive)
			{
				if (needToUncompress && CompressionMethod != 0 && CompressionMethod != CompressionMethodValues.Deflate)
				{
					message = Messages.UnsupportedCompression;
					return false;
				}
				if (_diskNumberStart != _archive.NumberOfThisDisk)
				{
					message = Messages.SplitSpanned;
					return false;
				}
				if (_offsetOfLocalHeader > _archive.ArchiveStream.Length)
				{
					message = Messages.LocalFileHeaderCorrupt;
					return false;
				}
				_archive.ArchiveStream.Seek(_offsetOfLocalHeader, SeekOrigin.Begin);
				if (!System.IO.Compression.ZipLocalFileHeader.TrySkipBlock(_archive.ArchiveReader))
				{
					message = Messages.LocalFileHeaderCorrupt;
					return false;
				}
				if (OffsetOfCompressedData + _compressedSize > _archive.ArchiveStream.Length)
				{
					message = Messages.LocalFileHeaderCorrupt;
					return false;
				}
				if (needToLoadIntoMemory && _compressedSize > int.MaxValue)
				{
					message = Messages.EntryTooLarge;
					return false;
				}
			}
			return true;
		}

		private bool SizesTooLarge()
		{
			if (_compressedSize <= uint.MaxValue)
			{
				return _uncompressedSize > uint.MaxValue;
			}
			return true;
		}

		private bool WriteLocalFileHeader(bool isEmptyFile)
		{
			BinaryWriter binaryWriter = new BinaryWriter(_archive.ArchiveStream);
			System.IO.Compression.Zip64ExtraField zip64ExtraField = default(System.IO.Compression.Zip64ExtraField);
			bool flag = false;
			uint value;
			uint value2;
			if (isEmptyFile)
			{
				CompressionMethod = CompressionMethodValues.Stored;
				value = 0u;
				value2 = 0u;
			}
			else if (_archive.Mode == ZipArchiveMode.Create && !_archive.ArchiveStream.CanSeek && !isEmptyFile)
			{
				_generalPurposeBitFlag |= BitFlagValues.DataDescriptor;
				flag = false;
				value = 0u;
				value2 = 0u;
			}
			else if (SizesTooLarge())
			{
				flag = true;
				value = uint.MaxValue;
				value2 = uint.MaxValue;
				zip64ExtraField.CompressedSize = _compressedSize;
				zip64ExtraField.UncompressedSize = _uncompressedSize;
				VersionToExtractAtLeast(System.IO.Compression.ZipVersionNeededValues.Zip64);
			}
			else
			{
				flag = false;
				value = (uint)_compressedSize;
				value2 = (uint)_uncompressedSize;
			}
			_offsetOfLocalHeader = binaryWriter.BaseStream.Position;
			int num = (flag ? zip64ExtraField.TotalSize : 0) + ((_lhUnknownExtraFields != null) ? System.IO.Compression.ZipGenericExtraField.TotalSize(_lhUnknownExtraFields) : 0);
			ushort value3;
			if (num > 65535)
			{
				value3 = (ushort)(flag ? zip64ExtraField.TotalSize : 0);
				_lhUnknownExtraFields = null;
			}
			else
			{
				value3 = (ushort)num;
			}
			binaryWriter.Write(67324752u);
			binaryWriter.Write((ushort)_versionToExtract);
			binaryWriter.Write((ushort)_generalPurposeBitFlag);
			binaryWriter.Write((ushort)CompressionMethod);
			binaryWriter.Write(System.IO.Compression.ZipHelper.DateTimeToDosTime(_lastModified.DateTime));
			binaryWriter.Write(_crc32);
			binaryWriter.Write(value);
			binaryWriter.Write(value2);
			binaryWriter.Write((ushort)_storedEntryNameBytes.Length);
			binaryWriter.Write(value3);
			binaryWriter.Write(_storedEntryNameBytes);
			if (flag)
			{
				zip64ExtraField.WriteBlock(_archive.ArchiveStream);
			}
			if (_lhUnknownExtraFields != null)
			{
				System.IO.Compression.ZipGenericExtraField.WriteAllBlocks(_lhUnknownExtraFields, _archive.ArchiveStream);
			}
			return flag;
		}

		private void WriteLocalFileHeaderAndDataIfNeeded()
		{
			if (_storedUncompressedData != null || _compressedBytes != null)
			{
				if (_storedUncompressedData != null)
				{
					_uncompressedSize = _storedUncompressedData.Length;
					using Stream destination = new DirectToArchiveWriterStream(GetDataCompressor(_archive.ArchiveStream, leaveBackingStreamOpen: true, null), this);
					_storedUncompressedData.Seek(0L, SeekOrigin.Begin);
					_storedUncompressedData.CopyTo(destination);
					_storedUncompressedData.Close();
					_storedUncompressedData = null;
					return;
				}
				if (_uncompressedSize == 0L)
				{
					CompressionMethod = CompressionMethodValues.Stored;
				}
				WriteLocalFileHeader(isEmptyFile: false);
				using MemoryStream memoryStream = new MemoryStream(_compressedBytes);
				memoryStream.CopyTo(_archive.ArchiveStream);
				return;
			}
			if (_archive.Mode == ZipArchiveMode.Update || !_everOpenedForWrite)
			{
				_everOpenedForWrite = true;
				WriteLocalFileHeader(isEmptyFile: true);
			}
		}

		private void WriteCrcAndSizesInLocalHeader(bool zip64HeaderUsed)
		{
			long position = _archive.ArchiveStream.Position;
			BinaryWriter binaryWriter = new BinaryWriter(_archive.ArchiveStream);
			bool flag = SizesTooLarge();
			bool flag2 = flag && !zip64HeaderUsed;
			uint value = (uint)(flag ? uint.MaxValue : _compressedSize);
			uint value2 = (uint)(flag ? uint.MaxValue : _uncompressedSize);
			if (flag2)
			{
				_generalPurposeBitFlag |= BitFlagValues.DataDescriptor;
				_archive.ArchiveStream.Seek(_offsetOfLocalHeader + 6, SeekOrigin.Begin);
				binaryWriter.Write((ushort)_generalPurposeBitFlag);
			}
			_archive.ArchiveStream.Seek(_offsetOfLocalHeader + 14, SeekOrigin.Begin);
			if (!flag2)
			{
				binaryWriter.Write(_crc32);
				binaryWriter.Write(value);
				binaryWriter.Write(value2);
			}
			else
			{
				binaryWriter.Write(0u);
				binaryWriter.Write(0u);
				binaryWriter.Write(0u);
			}
			if (zip64HeaderUsed)
			{
				_archive.ArchiveStream.Seek(_offsetOfLocalHeader + 30 + _storedEntryNameBytes.Length + 4, SeekOrigin.Begin);
				binaryWriter.Write(_uncompressedSize);
				binaryWriter.Write(_compressedSize);
				_archive.ArchiveStream.Seek(position, SeekOrigin.Begin);
			}
			_archive.ArchiveStream.Seek(position, SeekOrigin.Begin);
			if (flag2)
			{
				binaryWriter.Write(_crc32);
				binaryWriter.Write(_compressedSize);
				binaryWriter.Write(_uncompressedSize);
			}
		}

		private void WriteDataDescriptor()
		{
			BinaryWriter binaryWriter = new BinaryWriter(_archive.ArchiveStream);
			binaryWriter.Write(134695760u);
			binaryWriter.Write(_crc32);
			if (SizesTooLarge())
			{
				binaryWriter.Write(_compressedSize);
				binaryWriter.Write(_uncompressedSize);
			}
			else
			{
				binaryWriter.Write((uint)_compressedSize);
				binaryWriter.Write((uint)_uncompressedSize);
			}
		}

		private void UnloadStreams()
		{
			if (_storedUncompressedData != null)
			{
				_storedUncompressedData.Close();
			}
			_compressedBytes = null;
			_outstandingWriteStream = null;
		}

		private void CloseStreams()
		{
			if (_outstandingWriteStream != null)
			{
				_outstandingWriteStream.Close();
			}
		}

		private void VersionToExtractAtLeast(System.IO.Compression.ZipVersionNeededValues value)
		{
			if ((int)_versionToExtract < (int)value)
			{
				_versionToExtract = value;
			}
		}

		private void ThrowIfInvalidArchive()
		{
			if (_archive == null)
			{
				throw new InvalidOperationException(Messages.DeletedEntry);
			}
			_archive.ThrowIfDisposed();
		}
	}
	[__DynamicallyInvokable]
	internal enum ZipArchiveMode
	{
		[__DynamicallyInvokable]
		Read,
		[__DynamicallyInvokable]
		Create,
		[__DynamicallyInvokable]
		Update
	}
	internal struct ZipGenericExtraField
	{
		private const int SizeOfHeader = 4;

		private ushort _tag;

		private ushort _size;

		private byte[] _data;

		public ushort Tag => _tag;

		public ushort Size => _size;

		public byte[] Data => _data;

		public void WriteBlock(Stream stream)
		{
			BinaryWriter binaryWriter = new BinaryWriter(stream);
			binaryWriter.Write(Tag);
			binaryWriter.Write(Size);
			binaryWriter.Write(Data);
		}

		public static bool TryReadBlock(BinaryReader reader, long endExtraField, out System.IO.Compression.ZipGenericExtraField field)
		{
			field = default(System.IO.Compression.ZipGenericExtraField);
			if (endExtraField - reader.BaseStream.Position < 4)
			{
				return false;
			}
			field._tag = reader.ReadUInt16();
			field._size = reader.ReadUInt16();
			if (endExtraField - reader.BaseStream.Position < field._size)
			{
				return false;
			}
			field._data = reader.ReadBytes(field._size);
			return true;
		}

		public static List<System.IO.Compression.ZipGenericExtraField> ParseExtraField(Stream extraFieldData)
		{
			List<System.IO.Compression.ZipGenericExtraField> list = new List<System.IO.Compression.ZipGenericExtraField>();
			using BinaryReader reader = new BinaryReader(extraFieldData);
			System.IO.Compression.ZipGenericExtraField field;
			while (TryReadBlock(reader, extraFieldData.Length, out field))
			{
				list.Add(field);
			}
			return list;
		}

		public static int TotalSize(List<System.IO.Compression.ZipGenericExtraField> fields)
		{
			int num = 0;
			foreach (System.IO.Compression.ZipGenericExtraField field in fields)
			{
				num += field.Size + 4;
			}
			return num;
		}

		public static void WriteAllBlocks(List<System.IO.Compression.ZipGenericExtraField> fields, Stream stream)
		{
			foreach (System.IO.Compression.ZipGenericExtraField field in fields)
			{
				field.WriteBlock(stream);
			}
		}
	}
	internal struct Zip64ExtraField
	{
		public const int OffsetToFirstField = 4;

		private const ushort TagConstant = 1;

		private ushort _size;

		private long? _uncompressedSize;

		private long? _compressedSize;

		private long? _localHeaderOffset;

		private int? _startDiskNumber;

		public ushort TotalSize => (ushort)(_size + 4);

		public long? UncompressedSize
		{
			get
			{
				return _uncompressedSize;
			}
			set
			{
				_uncompressedSize = value;
				UpdateSize();
			}
		}

		public long? CompressedSize
		{
			get
			{
				return _compressedSize;
			}
			set
			{
				_compressedSize = value;
				UpdateSize();
			}
		}

		public long? LocalHeaderOffset
		{
			get
			{
				return _localHeaderOffset;
			}
			set
			{
				_localHeaderOffset = value;
				UpdateSize();
			}
		}

		public int? StartDiskNumber => _startDiskNumber;

		private void UpdateSize()
		{
			_size = 0;
			if (_uncompressedSize.HasValue)
			{
				_size += 8;
			}
			if (_compressedSize.HasValue)
			{
				_size += 8;
			}
			if (_localHeaderOffset.HasValue)
			{
				_size += 8;
			}
			if (_startDiskNumber.HasValue)
			{
				_size += 4;
			}
		}

		public static System.IO.Compression.Zip64ExtraField GetJustZip64Block(Stream extraFieldStream, bool readUncompressedSize, bool readCompressedSize, bool readLocalHeaderOffset, bool readStartDiskNumber)
		{
			System.IO.Compression.Zip64ExtraField zip64Block;
			using (BinaryReader reader = new BinaryReader(extraFieldStream))
			{
				System.IO.Compression.ZipGenericExtraField field;
				while (System.IO.Compression.ZipGenericExtraField.TryReadBlock(reader, extraFieldStream.Length, out field))
				{
					if (TryGetZip64BlockFromGenericExtraField(field, readUncompressedSize, readCompressedSize, readLocalHeaderOffset, readStartDiskNumber, out zip64Block))
					{
						return zip64Block;
					}
				}
			}
			zip64Block = default(System.IO.Compression.Zip64ExtraField);
			zip64Block._compressedSize = null;
			zip64Block._uncompressedSize = null;
			zip64Block._localHeaderOffset = null;
			zip64Block._startDiskNumber = null;
			return zip64Block;
		}

		private static bool TryGetZip64BlockFromGenericExtraField(System.IO.Compression.ZipGenericExtraField extraField, bool readUncompressedSize, bool readCompressedSize, bool readLocalHeaderOffset, bool readStartDiskNumber, out System.IO.Compression.Zip64ExtraField zip64Block)
		{
			zip64Block = default(System.IO.Compression.Zip64ExtraField);
			zip64Block._compressedSize = null;
			zip64Block._uncompressedSize = null;
			zip64Block._localHeaderOffset = null;
			zip64Block._startDiskNumber = null;
			if (extraField.Tag != 1)
			{
				return false;
			}
			MemoryStream memoryStream = null;
			try
			{
				memoryStream = new MemoryStream(extraField.Data);
				using BinaryReader binaryReader = new BinaryReader(memoryStream);
				memoryStream = null;
				zip64Block._size = extraField.Size;
				ushort num = 0;
				if (readUncompressedSize)
				{
					num += 8;
				}
				if (readCompressedSize)
				{
					num += 8;
				}
				if (readLocalHeaderOffset)
				{
					num += 8;
				}
				if (readStartDiskNumber)
				{
					num += 4;
				}
				if (num != zip64Block._size)
				{
					return false;
				}
				if (readUncompressedSize)
				{
					zip64Block._uncompressedSize = binaryReader.ReadInt64();
				}
				if (readCompressedSize)
				{
					zip64Block._compressedSize = binaryReader.ReadInt64();
				}
				if (readLocalHeaderOffset)
				{
					zip64Block._localHeaderOffset = binaryReader.ReadInt64();
				}
				if (readStartDiskNumber)
				{
					zip64Block._startDiskNumber = binaryReader.ReadInt32();
				}
				if (zip64Block._uncompressedSize < 0)
				{
					throw new InvalidDataException(Messages.FieldTooBigUncompressedSize);
				}
				if (zip64Block._compressedSize < 0)
				{
					throw new InvalidDataException(Messages.FieldTooBigCompressedSize);
				}
				if (zip64Block._localHeaderOffset < 0)
				{
					throw new InvalidDataException(Messages.FieldTooBigLocalHeaderOffset);
				}
				if (zip64Block._startDiskNumber < 0)
				{
					throw new InvalidDataException(Messages.FieldTooBigStartDiskNumber);
				}
				return true;
			}
			finally
			{
				memoryStream?.Close();
			}
		}

		public static System.IO.Compression.Zip64ExtraField GetAndRemoveZip64Block(List<System.IO.Compression.ZipGenericExtraField> extraFields, bool readUncompressedSize, bool readCompressedSize, bool readLocalHeaderOffset, bool readStartDiskNumber)
		{
			System.IO.Compression.Zip64ExtraField zip64Block = default(System.IO.Compression.Zip64ExtraField);
			zip64Block._compressedSize = null;
			zip64Block._uncompressedSize = null;
			zip64Block._localHeaderOffset = null;
			zip64Block._startDiskNumber = null;
			List<System.IO.Compression.ZipGenericExtraField> list = new List<System.IO.Compression.ZipGenericExtraField>();
			bool flag = false;
			foreach (System.IO.Compression.ZipGenericExtraField extraField in extraFields)
			{
				if (extraField.Tag == 1)
				{
					list.Add(extraField);
					if (!flag && TryGetZip64BlockFromGenericExtraField(extraField, readUncompressedSize, readCompressedSize, readLocalHeaderOffset, readStartDiskNumber, out zip64Block))
					{
						flag = true;
					}
				}
			}
			foreach (System.IO.Compression.ZipGenericExtraField item in list)
			{
				extraFields.Remove(item);
			}
			return zip64Block;
		}

		public static void RemoveZip64Blocks(List<System.IO.Compression.ZipGenericExtraField> extraFields)
		{
			List<System.IO.Compression.ZipGenericExtraField> list = new List<System.IO.Compression.ZipGenericExtraField>();
			foreach (System.IO.Compression.ZipGenericExtraField extraField in extraFields)
			{
				if (extraField.Tag == 1)
				{
					list.Add(extraField);
				}
			}
			foreach (System.IO.Compression.ZipGenericExtraField item in list)
			{
				extraFields.Remove(item);
			}
		}

		public void WriteBlock(Stream stream)
		{
			BinaryWriter binaryWriter = new BinaryWriter(stream);
			binaryWriter.Write((ushort)1);
			binaryWriter.Write(_size);
			if (_uncompressedSize.HasValue)
			{
				binaryWriter.Write(_uncompressedSize.Value);
			}
			if (_compressedSize.HasValue)
			{
				binaryWriter.Write(_compressedSize.Value);
			}
			if (_localHeaderOffset.HasValue)
			{
				binaryWriter.Write(_localHeaderOffset.Value);
			}
			if (_startDiskNumber.HasValue)
			{
				binaryWriter.Write(_startDiskNumber.Value);
			}
		}
	}
	internal struct Zip64EndOfCentralDirectoryLocator
	{
		public const uint SignatureConstant = 117853008u;

		public const int SizeOfBlockWithoutSignature = 16;

		public uint NumberOfDiskWithZip64EOCD;

		public ulong OffsetOfZip64EOCD;

		public uint TotalNumberOfDisks;

		public static bool TryReadBlock(BinaryReader reader, out System.IO.Compression.Zip64EndOfCentralDirectoryLocator zip64EOCDLocator)
		{
			zip64EOCDLocator = default(System.IO.Compression.Zip64EndOfCentralDirectoryLocator);
			if (reader.ReadUInt32() != 117853008)
			{
				return false;
			}
			zip64EOCDLocator.NumberOfDiskWithZip64EOCD = reader.ReadUInt32();
			zip64EOCDLocator.OffsetOfZip64EOCD = reader.ReadUInt64();
			zip64EOCDLocator.TotalNumberOfDisks = reader.ReadUInt32();
			return true;
		}

		public static void WriteBlock(Stream stream, long zip64EOCDRecordStart)
		{
			BinaryWriter binaryWriter = new BinaryWriter(stream);
			binaryWriter.Write(117853008u);
			binaryWriter.Write(0u);
			binaryWriter.Write(zip64EOCDRecordStart);
			binaryWriter.Write(1u);
		}
	}
	internal struct Zip64EndOfCentralDirectoryRecord
	{
		private const uint SignatureConstant = 101075792u;

		private const ulong NormalSize = 44uL;

		public ulong SizeOfThisRecord;

		public ushort VersionMadeBy;

		public ushort VersionNeededToExtract;

		public uint NumberOfThisDisk;

		public uint NumberOfDiskWithStartOfCD;

		public ulong NumberOfEntriesOnThisDisk;

		public ulong NumberOfEntriesTotal;

		public ulong SizeOfCentralDirectory;

		public ulong OffsetOfCentralDirectory;

		public static bool TryReadBlock(BinaryReader reader, out System.IO.Compression.Zip64EndOfCentralDirectoryRecord zip64EOCDRecord)
		{
			zip64EOCDRecord = default(System.IO.Compression.Zip64EndOfCentralDirectoryRecord);
			if (reader.ReadUInt32() != 101075792)
			{
				return false;
			}
			zip64EOCDRecord.SizeOfThisRecord = reader.ReadUInt64();
			zip64EOCDRecord.VersionMadeBy = reader.ReadUInt16();
			zip64EOCDRecord.VersionNeededToExtract = reader.ReadUInt16();
			zip64EOCDRecord.NumberOfThisDisk = reader.ReadUInt32();
			zip64EOCDRecord.NumberOfDiskWithStartOfCD = reader.ReadUInt32();
			zip64EOCDRecord.NumberOfEntriesOnThisDisk = reader.ReadUInt64();
			zip64EOCDRecord.NumberOfEntriesTotal = reader.ReadUInt64();
			zip64EOCDRecord.SizeOfCentralDirectory = reader.ReadUInt64();
			zip64EOCDRecord.OffsetOfCentralDirectory = reader.ReadUInt64();
			return true;
		}

		public static void WriteBlock(Stream stream, long numberOfEntries, long startOfCentralDirectory, long sizeOfCentralDirectory)
		{
			BinaryWriter binaryWriter = new BinaryWriter(stream);
			binaryWriter.Write(101075792u);
			binaryWriter.Write(44uL);
			binaryWriter.Write((ushort)45);
			binaryWriter.Write((ushort)45);
			binaryWriter.Write(0u);
			binaryWriter.Write(0u);
			binaryWriter.Write(numberOfEntries);
			binaryWriter.Write(numberOfEntries);
			binaryWriter.Write(sizeOfCentralDirectory);
			binaryWriter.Write(startOfCentralDirectory);
		}
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	internal struct ZipLocalFileHeader
	{
		public const uint DataDescriptorSignature = 134695760u;

		public const uint SignatureConstant = 67324752u;

		public const int OffsetToCrcFromHeaderStart = 14;

		public const int OffsetToBitFlagFromHeaderStart = 6;

		public const int SizeOfLocalHeader = 30;

		public static List<System.IO.Compression.ZipGenericExtraField> GetExtraFields(BinaryReader reader)
		{
			reader.BaseStream.Seek(26L, SeekOrigin.Current);
			ushort num = reader.ReadUInt16();
			ushort num2 = reader.ReadUInt16();
			reader.BaseStream.Seek(num, SeekOrigin.Current);
			List<System.IO.Compression.ZipGenericExtraField> list;
			using (Stream extraFieldData = new System.IO.Compression.SubReadStream(reader.BaseStream, reader.BaseStream.Position, num2))
			{
				list = System.IO.Compression.ZipGenericExtraField.ParseExtraField(extraFieldData);
			}
			System.IO.Compression.Zip64ExtraField.RemoveZip64Blocks(list);
			return list;
		}

		public static bool TrySkipBlock(BinaryReader reader)
		{
			if (reader.ReadUInt32() != 67324752)
			{
				return false;
			}
			if (reader.BaseStream.Length < reader.BaseStream.Position + 22)
			{
				return false;
			}
			reader.BaseStream.Seek(22L, SeekOrigin.Current);
			ushort num = reader.ReadUInt16();
			ushort num2 = reader.ReadUInt16();
			if (reader.BaseStream.Length < reader.BaseStream.Position + num + num2)
			{
				return false;
			}
			reader.BaseStream.Seek(num + num2, SeekOrigin.Current);
			return true;
		}
	}
	internal struct ZipCentralDirectoryFileHeader
	{
		public const uint SignatureConstant = 33639248u;

		public ushort VersionMadeBy;

		public ushort VersionNeededToExtract;

		public ushort GeneralPurposeBitFlag;

		public ushort CompressionMethod;

		public uint LastModified;

		public uint Crc32;

		public long CompressedSize;

		public long UncompressedSize;

		public ushort FilenameLength;

		public ushort ExtraFieldLength;

		public ushort FileCommentLength;

		public int DiskNumberStart;

		public ushort InternalFileAttributes;

		public uint ExternalFileAttributes;

		public long RelativeOffsetOfLocalHeader;

		public byte[] Filename;

		public byte[] FileComment;

		public List<System.IO.Compression.ZipGenericExtraField> ExtraFields;

		public static bool TryReadBlock(BinaryReader reader, bool saveExtraFieldsAndComments, out System.IO.Compression.ZipCentralDirectoryFileHeader header)
		{
			header = default(System.IO.Compression.ZipCentralDirectoryFileHeader);
			if (reader.ReadUInt32() != 33639248)
			{
				return false;
			}
			header.VersionMadeBy = reader.ReadUInt16();
			header.VersionNeededToExtract = reader.ReadUInt16();
			header.GeneralPurposeBitFlag = reader.ReadUInt16();
			header.CompressionMethod = reader.ReadUInt16();
			header.LastModified = reader.ReadUInt32();
			header.Crc32 = reader.ReadUInt32();
			uint num = reader.ReadUInt32();
			uint num2 = reader.ReadUInt32();
			header.FilenameLength = reader.ReadUInt16();
			header.ExtraFieldLength = reader.ReadUInt16();
			header.FileCommentLength = reader.ReadUInt16();
			ushort num3 = reader.ReadUInt16();
			header.InternalFileAttributes = reader.ReadUInt16();
			header.ExternalFileAttributes = reader.ReadUInt32();
			uint num4 = reader.ReadUInt32();
			header.Filename = reader.ReadBytes(header.FilenameLength);
			bool readUncompressedSize = num2 == uint.MaxValue;
			bool readCompressedSize = num == uint.MaxValue;
			bool readLocalHeaderOffset = num4 == uint.MaxValue;
			bool readStartDiskNumber = num3 == ushort.MaxValue;
			long position = reader.BaseStream.Position + header.ExtraFieldLength;
			System.IO.Compression.Zip64ExtraField zip64ExtraField;
			using (Stream stream = new System.IO.Compression.SubReadStream(reader.BaseStream, reader.BaseStream.Position, header.ExtraFieldLength))
			{
				if (saveExtraFieldsAndComments)
				{
					header.ExtraFields = System.IO.Compression.ZipGenericExtraField.ParseExtraField(stream);
					zip64ExtraField = System.IO.Compression.Zip64ExtraField.GetAndRemoveZip64Block(header.ExtraFields, readUncompressedSize, readCompressedSize, readLocalHeaderOffset, readStartDiskNumber);
				}
				else
				{
					header.ExtraFields = null;
					zip64ExtraField = System.IO.Compression.Zip64ExtraField.GetJustZip64Block(stream, readUncompressedSize, readCompressedSize, readLocalHeaderOffset, readStartDiskNumber);
				}
			}
			reader.BaseStream.AdvanceToPosition(position);
			if (saveExtraFieldsAndComments)
			{
				header.FileComment = reader.ReadBytes(header.FileCommentLength);
			}
			else
			{
				reader.BaseStream.Position += header.FileCommentLength;
				header.FileComment = null;
			}
			header.UncompressedSize = ((!zip64ExtraField.UncompressedSize.HasValue) ? num2 : zip64ExtraField.UncompressedSize.Value);
			header.CompressedSize = ((!zip64ExtraField.CompressedSize.HasValue) ? num : zip64ExtraField.CompressedSize.Value);
			header.RelativeOffsetOfLocalHeader = ((!zip64ExtraField.LocalHeaderOffset.HasValue) ? num4 : zip64ExtraField.LocalHeaderOffset.Value);
			header.DiskNumberStart = ((!zip64ExtraField.StartDiskNumber.HasValue) ? num3 : zip64ExtraField.StartDiskNumber.Value);
			return true;
		}
	}
	internal struct ZipEndOfCentralDirectoryBlock
	{
		public const uint SignatureConstant = 101010256u;

		public const int SizeOfBlockWithoutSignature = 18;

		public uint Signature;

		public ushort NumberOfThisDisk;

		public ushort NumberOfTheDiskWithTheStartOfTheCentralDirectory;

		public ushort NumberOfEntriesInTheCentralDirectoryOnThisDisk;

		public ushort NumberOfEntriesInTheCentralDirectory;

		public uint SizeOfCentralDirectory;

		public uint OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber;

		public byte[] ArchiveComment;

		public static void WriteBlock(Stream stream, long numberOfEntries, long startOfCentralDirectory, long sizeOfCentralDirectory, byte[] archiveComment)
		{
			BinaryWriter binaryWriter = new BinaryWriter(stream);
			ushort value = ((numberOfEntries > 65535) ? ushort.MaxValue : ((ushort)numberOfEntries));
			uint value2 = (uint)((startOfCentralDirectory > uint.MaxValue) ? uint.MaxValue : startOfCentralDirectory);
			uint value3 = (uint)((sizeOfCentralDirectory > uint.MaxValue) ? uint.MaxValue : sizeOfCentralDirectory);
			binaryWriter.Write(101010256u);
			binaryWriter.Write((ushort)0);
			binaryWriter.Write((ushort)0);
			binaryWriter.Write(value);
			binaryWriter.Write(value);
			binaryWriter.Write(value3);
			binaryWriter.Write(value2);
			binaryWriter.Write((ushort)((archiveComment != null) ? ((ushort)archiveComment.Length) : 0));
			if (archiveComment != null)
			{
				binaryWriter.Write(archiveComment);
			}
		}

		public static bool TryReadBlock(BinaryReader reader, out System.IO.Compression.ZipEndOfCentralDirectoryBlock eocdBlock)
		{
			eocdBlock = default(System.IO.Compression.ZipEndOfCentralDirectoryBlock);
			if (reader.ReadUInt32() != 101010256)
			{
				return false;
			}
			eocdBlock.Signature = 101010256u;
			eocdBlock.NumberOfThisDisk = reader.ReadUInt16();
			eocdBlock.NumberOfTheDiskWithTheStartOfTheCentralDirectory = reader.ReadUInt16();
			eocdBlock.NumberOfEntriesInTheCentralDirectoryOnThisDisk = reader.ReadUInt16();
			eocdBlock.NumberOfEntriesInTheCentralDirectory = reader.ReadUInt16();
			eocdBlock.SizeOfCentralDirectory = reader.ReadUInt32();
			eocdBlock.OffsetOfStartOfCentralDirectoryWithRespectToTheStartingDiskNumber = reader.ReadUInt32();
			ushort count = reader.ReadUInt16();
			eocdBlock.ArchiveComment = reader.ReadBytes(count);
			return true;
		}
	}
	internal static class ZipHelper
	{
		internal const uint Mask32Bit = uint.MaxValue;

		internal const ushort Mask16Bit = ushort.MaxValue;

		private const int BackwardsSeekingBufferSize = 32;

		internal const int ValidZipDate_YearMin = 1980;

		internal const int ValidZipDate_YearMax = 2107;

		private static readonly DateTime InvalidDateIndicator = new DateTime(1980, 1, 1, 0, 0, 0);

		internal static bool EndsWithDirChar(string test)
		{
			return Path.GetFileName(test) == "";
		}

		internal static bool RequiresUnicode(string test)
		{
			foreach (char c in test)
			{
				if (c > '\u007f')
				{
					return true;
				}
			}
			return false;
		}

		internal static void ReadBytes(Stream stream, byte[] buffer, int bytesToRead)
		{
			int num = bytesToRead;
			int num2 = 0;
			while (num > 0)
			{
				int num3 = stream.Read(buffer, num2, num);
				if (num3 == 0)
				{
					throw new IOException(Messages.UnexpectedEndOfStream);
				}
				num2 += num3;
				num -= num3;
			}
		}

		internal static DateTime DosTimeToDateTime(uint dateTime)
		{
			int year = (int)(1980 + (dateTime >> 25));
			int month = (int)((dateTime >> 21) & 0xF);
			int day = (int)((dateTime >> 16) & 0x1F);
			int hour = (int)((dateTime >> 11) & 0x1F);
			int minute = (int)((dateTime >> 5) & 0x3F);
			int second = (int)((dateTime & 0x1F) * 2);
			try
			{
				return new DateTime(year, month, day, hour, minute, second, 0);
			}
			catch (ArgumentOutOfRangeException)
			{
				return InvalidDateIndicator;
			}
			catch (ArgumentException)
			{
				return InvalidDateIndicator;
			}
		}

		internal static uint DateTimeToDosTime(DateTime dateTime)
		{
			int num = (dateTime.Year - 1980) & 0x7F;
			num = (num << 4) + dateTime.Month;
			num = (num << 5) + dateTime.Day;
			num = (num << 5) + dateTime.Hour;
			num = (num << 6) + dateTime.Minute;
			return (uint)((num << 5) + dateTime.Second / 2);
		}

		internal static bool SeekBackwardsToSignature(Stream stream, uint signatureToFind)
		{
			int bufferPointer = 0;
			uint num = 0u;
			byte[] array = new byte[32];
			bool flag = false;
			bool flag2 = false;
			while (!flag2 && !flag)
			{
				flag = SeekBackwardsAndRead(stream, array, out bufferPointer);
				while (bufferPointer >= 0 && !flag2)
				{
					num = (num << 8) | array[bufferPointer];
					if (num == signatureToFind)
					{
						flag2 = true;
					}
					else
					{
						bufferPointer--;
					}
				}
			}
			if (!flag2)
			{
				return false;
			}
			stream.Seek(bufferPointer, SeekOrigin.Current);
			return true;
		}

		internal static void AdvanceToPosition(this Stream stream, long position)
		{
			long num = position - stream.Position;
			while (num != 0L)
			{
				int count = (int)((num > 64) ? 64 : num);
				int num2 = stream.Read(new byte[64], 0, count);
				if (num2 == 0)
				{
					throw new IOException(Messages.UnexpectedEndOfStream);
				}
				num -= num2;
			}
		}

		private static bool SeekBackwardsAndRead(Stream stream, byte[] buffer, out int bufferPointer)
		{
			if (stream.Position >= buffer.Length)
			{
				stream.Seek(-buffer.Length, SeekOrigin.Current);
				ReadBytes(stream, buffer, buffer.Length);
				stream.Seek(-buffer.Length, SeekOrigin.Current);
				bufferPointer = buffer.Length - 1;
				return false;
			}
			int num = (int)stream.Position;
			stream.Seek(0L, SeekOrigin.Begin);
			ReadBytes(stream, buffer, num);
			stream.Seek(0L, SeekOrigin.Begin);
			bufferPointer = num - 1;
			return true;
		}
	}
	internal enum ZipVersionNeededValues : ushort
	{
		Default = 10,
		ExplicitDirectory = 20,
		Deflate = 20,
		Zip64 = 45
	}
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Messages
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					ResourceManager resourceManager = new ResourceManager("System.IO.Compression.Messages", typeof(Messages).Assembly);
					resourceMan = resourceManager;
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static string ArgumentNeedNonNegative => ResourceManager.GetString("ArgumentNeedNonNegative", resourceCulture);

		internal static string CannotBeEmpty => ResourceManager.GetString("CannotBeEmpty", resourceCulture);

		internal static string CDCorrupt => ResourceManager.GetString("CDCorrupt", resourceCulture);

		internal static string CentralDirectoryInvalid => ResourceManager.GetString("CentralDirectoryInvalid", resourceCulture);

		internal static string CreateInReadMode => ResourceManager.GetString("CreateInReadMode", resourceCulture);

		internal static string CreateModeCapabilities => ResourceManager.GetString("CreateModeCapabilities", resourceCulture);

		internal static string CreateModeCreateEntryWhileOpen => ResourceManager.GetString("CreateModeCreateEntryWhileOpen", resourceCulture);

		internal static string CreateModeWriteOnceAndOneEntryAtATime => ResourceManager.GetString("CreateModeWriteOnceAndOneEntryAtATime", resourceCulture);

		internal static string DateTimeInvalid => ResourceManager.GetString("DateTimeInvalid", resourceCulture);

		internal static string DateTimeOutOfRange => ResourceManager.GetString("DateTimeOutOfRange", resourceCulture);

		internal static string DeletedEntry => ResourceManager.GetString("DeletedEntry", resourceCulture);

		internal static string DeleteOnlyInUpdate => ResourceManager.GetString("DeleteOnlyInUpdate", resourceCulture);

		internal static string DeleteOpenEntry => ResourceManager.GetString("DeleteOpenEntry", resourceCulture);

		internal static string EntriesInCreateMode => ResourceManager.GetString("EntriesInCreateMode", resourceCulture);

		internal static string EntryNameEncodingNotSupported => ResourceManager.GetString("EntryNameEncodingNotSupported", resourceCulture);

		internal static string EntryNamesTooLong => ResourceManager.GetString("EntryNamesTooLong", resourceCulture);

		internal static string EntryTooLarge => ResourceManager.GetString("EntryTooLarge", resourceCulture);

		internal static string EOCDNotFound => ResourceManager.GetString("EOCDNotFound", resourceCulture);

		internal static string FieldTooBigCompressedSize => ResourceManager.GetString("FieldTooBigCompressedSize", resourceCulture);

		internal static string FieldTooBigLocalHeaderOffset => ResourceManager.GetString("FieldTooBigLocalHeaderOffset", resourceCulture);

		internal static string FieldTooBigNumEntries => ResourceManager.GetString("FieldTooBigNumEntries", resourceCulture);

		internal static string FieldTooBigOffsetToCD => ResourceManager.GetString("FieldTooBigOffsetToCD", resourceCulture);

		internal static string FieldTooBigOffsetToZip64EOCD => ResourceManager.GetString("FieldTooBigOffsetToZip64EOCD", resourceCulture);

		internal static string FieldTooBigStartDiskNumber => ResourceManager.GetString("FieldTooBigStartDiskNumber", resourceCulture);

		internal static string FieldTooBigUncompressedSize => ResourceManager.GetString("FieldTooBigUncompressedSize", resourceCulture);

		internal static string FrozenAfterWrite => ResourceManager.GetString("FrozenAfterWrite", resourceCulture);

		internal static string HiddenStreamName => ResourceManager.GetString("HiddenStreamName", resourceCulture);

		internal static string LengthAfterWrite => ResourceManager.GetString("LengthAfterWrite", resourceCulture);

		internal static string LocalFileHeaderCorrupt => ResourceManager.GetString("LocalFileHeaderCorrupt", resourceCulture);

		internal static string NumEntriesWrong => ResourceManager.GetString("NumEntriesWrong", resourceCulture);

		internal static string OffsetLengthInvalid => ResourceManager.GetString("OffsetLengthInvalid", resourceCulture);

		internal static string ReadingNotSupported => ResourceManager.GetString("ReadingNotSupported", resourceCulture);

		internal static string ReadModeCapabilities => ResourceManager.GetString("ReadModeCapabilities", resourceCulture);

		internal static string ReadOnlyArchive => ResourceManager.GetString("ReadOnlyArchive", resourceCulture);

		internal static string SeekingNotSupported => ResourceManager.GetString("SeekingNotSupported", resourceCulture);

		internal static string SetLengthRequiresSeekingAndWriting => ResourceManager.GetString("SetLengthRequiresSeekingAndWriting", resourceCulture);

		internal static string SplitSpanned => ResourceManager.GetString("SplitSpanned", resourceCulture);

		internal static string UnexpectedEndOfStream => ResourceManager.GetString("UnexpectedEndOfStream", resourceCulture);

		internal static string UnsupportedCompression => ResourceManager.GetString("UnsupportedCompression", resourceCulture);

		internal static string UpdateModeCapabilities => ResourceManager.GetString("UpdateModeCapabilities", resourceCulture);

		internal static string UpdateModeOneStream => ResourceManager.GetString("UpdateModeOneStream", resourceCulture);

		internal static string WritingNotSupported => ResourceManager.GetString("WritingNotSupported", resourceCulture);

		internal static string Zip64EOCDNotWhereExpected => ResourceManager.GetString("Zip64EOCDNotWhereExpected", resourceCulture);

		internal Messages()
		{
		}
	}
}
[CompilerGenerated]
internal sealed class <a7d4235f-4b3b-40e1-8a48-1750eedfe86b><PrivateImplementationDetails>
{
	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 1024)]
	private struct __StaticArrayInitTypeSize=1024
	{
	}

	internal static readonly __StaticArrayInitTypeSize=1024 12F3E0576D447EB37B36D82BA0C1C5481B8F0D12FDC70347CE4A076B229D4C86/* Not supported: data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
}
[AttributeUsage(AttributeTargets.All, Inherited = false)]
internal sealed class __DynamicallyInvokableAttribute : Attribute
{
}
namespace System
{
	internal static class AppContextDefaultValues
	{
		public static void PopulateDefaultValues()
		{
			ParseTargetFrameworkName(out var identifier, out var profile, out var version);
			PopulateDefaultValuesPartial(identifier, profile, version);
		}

		private static void ParseTargetFrameworkName(out string identifier, out string profile, out int version)
		{
			string targetFrameworkName = AppDomain.CurrentDomain.SetupInformation.TargetFrameworkName;
			if (!TryParseFrameworkName(targetFrameworkName, out identifier, out version, out profile))
			{
				identifier = ".NETFramework";
				version = 40000;
				profile = string.Empty;
			}
		}

		private static bool TryParseFrameworkName(string frameworkName, out string identifier, out int version, out string profile)
		{
			identifier = (profile = string.Empty);
			version = 0;
			if (frameworkName == null || frameworkName.Length == 0)
			{
				return false;
			}
			string[] array = frameworkName.Split(new char[1] { ',' });
			version = 0;
			if (array.Length < 2 || array.Length > 3)
			{
				return false;
			}
			identifier = array[0].Trim();
			if (identifier.Length == 0)
			{
				return false;
			}
			bool flag = false;
			profile = null;
			for (int i = 1; i < array.Length; i++)
			{
				string[] array2 = array[i].Split(new char[1] { '=' });
				if (array2.Length != 2)
				{
					return false;
				}
				string text = array2[0].Trim();
				string text2 = array2[1].Trim();
				if (text.Equals("Version", StringComparison.OrdinalIgnoreCase))
				{
					flag = true;
					if (text2.Length > 0 && (text2[0] == 'v' || text2[0] == 'V'))
					{
						text2 = text2.Substring(1);
					}
					Version version2 = new Version(text2);
					version = version2.Major * 10000;
					if (version2.Minor > 0)
					{
						version += version2.Minor * 100;
					}
					if (version2.Build > 0)
					{
						version += version2.Build;
					}
				}
				else
				{
					if (!text.Equals("Profile", StringComparison.OrdinalIgnoreCase))
					{
						return false;
					}
					if (!string.IsNullOrEmpty(text2))
					{
						profile = text2;
					}
				}
			}
			if (!flag)
			{
				return false;
			}
			return true;
		}

		private static void PopulateDefaultValuesPartial(string platformIdentifier, string profile, int version)
		{
			switch (platformIdentifier)
			{
			case ".NETCore":
			case ".NETFramework":
				if (version <= 40600)
				{
					LocalAppContext.DefineSwitchDefault("Switch.System.IO.Compression.ZipFile.UseBackslash", initialValue: true);
				}
				break;
			case "WindowsPhone":
			case "WindowsPhoneApp":
				if (version <= 80100)
				{
					LocalAppContext.DefineSwitchDefault("Switch.System.IO.Compression.ZipFile.UseBackslash", initialValue: true);
				}
				break;
			}
		}
	}
	internal static class LocalAppContextSwitches
	{
		private static int _zipFileUseBackslash;

		private static int _doNotAddTrailingSeparator;

		internal const string ZipFileUseBackslashName = "Switch.System.IO.Compression.ZipFile.UseBackslash";

		internal const string DoNotAddTrailingSeparatorString = "Switch.System.IO.Compression.DoNotAddTrailingSeparator";

		public static bool ZipFileUseBackslash
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return LocalAppContext.GetCachedSwitchValue("Switch.System.IO.Compression.ZipFile.UseBackslash", ref _zipFileUseBackslash);
			}
		}

		public static bool DoNotAddTrailingSeparator
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return LocalAppContext.GetCachedSwitchValue("Switch.System.IO.Compression.DoNotAddTrailingSeparator", ref _doNotAddTrailingSeparator);
			}
		}
	}
	internal static class LocalAppContext
	{
		private delegate bool TryGetSwitchDelegate(string switchName, out bool value);

		private static TryGetSwitchDelegate TryGetSwitchFromCentralAppContext;

		private static bool s_canForwardCalls;

		private static Dictionary<string, bool> s_switchMap;

		private static readonly object s_syncLock;

		private static bool DisableCaching { get; set; }

		static LocalAppContext()
		{
			s_switchMap = new Dictionary<string, bool>();
			s_syncLock = new object();
			s_canForwardCalls = SetupDelegate();
			AppContextDefaultValues.PopulateDefaultValues();
			DisableCaching = IsSwitchEnabled("TestSwitch.LocalAppContext.DisableCaching");
		}

		public static bool IsSwitchEnabled(string switchName)
		{
			if (s_canForwardCalls && TryGetSwitchFromCentralAppContext(switchName, out var value))
			{
				return value;
			}
			return IsSwitchEnabledLocal(switchName);
		}

		private static bool IsSwitchEnabledLocal(string switchName)
		{
			bool flag;
			bool value;
			lock (s_switchMap)
			{
				flag = s_switchMap.TryGetValue(switchName, out value);
			}
			if (flag)
			{
				return value;
			}
			return false;
		}

		private static bool SetupDelegate()
		{
			Type type = typeof(object).Assembly.GetType("System.AppContext");
			if (type == null)
			{
				return false;
			}
			MethodInfo method = type.GetMethod("TryGetSwitch", BindingFlags.Static | BindingFlags.Public, null, new Type[2]
			{
				typeof(string),
				typeof(bool).MakeByRefType()
			}, null);
			if (method == null)
			{
				return false;
			}
			TryGetSwitchFromCentralAppContext = (TryGetSwitchDelegate)Delegate.CreateDelegate(typeof(TryGetSwitchDelegate), method);
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool GetCachedSwitchValue(string switchName, ref int switchValue)
		{
			if (switchValue < 0)
			{
				return false;
			}
			if (switchValue > 0)
			{
				return true;
			}
			return GetCachedSwitchValueInternal(switchName, ref switchValue);
		}

		private static bool GetCachedSwitchValueInternal(string switchName, ref int switchValue)
		{
			if (DisableCaching)
			{
				return IsSwitchEnabled(switchName);
			}
			bool flag = IsSwitchEnabled(switchName);
			switchValue = (flag ? 1 : (-1));
			return flag;
		}

		internal static void DefineSwitchDefault(string switchName, bool initialValue)
		{
			s_switchMap[switchName] = initialValue;
		}
	}
}
namespace System.IO.Compression
{
	internal static class ZipFile
	{
		private static readonly char s_pathSeperator = (System.LocalAppContextSwitches.ZipFileUseBackslash ? '\\' : '/');

		public static ZipArchive OpenRead(string archiveFileName)
		{
			return Open(archiveFileName, ZipArchiveMode.Read);
		}

		public static ZipArchive Open(string archiveFileName, ZipArchiveMode mode)
		{
			return Open(archiveFileName, mode, null);
		}

		public static ZipArchive Open(string archiveFileName, ZipArchiveMode mode, Encoding entryNameEncoding)
		{
			FileMode mode2;
			FileAccess access;
			FileShare share;
			switch (mode)
			{
			case ZipArchiveMode.Read:
				mode2 = FileMode.Open;
				access = FileAccess.Read;
				share = FileShare.Read;
				break;
			case ZipArchiveMode.Create:
				mode2 = FileMode.CreateNew;
				access = FileAccess.Write;
				share = FileShare.None;
				break;
			case ZipArchiveMode.Update:
				mode2 = FileMode.OpenOrCreate;
				access = FileAccess.ReadWrite;
				share = FileShare.None;
				break;
			default:
				throw new ArgumentOutOfRangeException("mode");
			}
			FileStream fileStream = null;
			try
			{
				fileStream = File.Open(archiveFileName, mode2, access, share);
				return new ZipArchive(fileStream, mode, leaveOpen: false, entryNameEncoding);
			}
			catch
			{
				fileStream?.Dispose();
				throw;
			}
		}

		public static void CreateFromDirectory(string sourceDirectoryName, string destinationArchiveFileName)
		{
			DoCreateFromDirectory(sourceDirectoryName, destinationArchiveFileName, null, includeBaseDirectory: false, null);
		}

		public static void CreateFromDirectory(string sourceDirectoryName, string destinationArchiveFileName, CompressionLevel compressionLevel, bool includeBaseDirectory)
		{
			DoCreateFromDirectory(sourceDirectoryName, destinationArchiveFileName, compressionLevel, includeBaseDirectory, null);
		}

		public static void CreateFromDirectory(string sourceDirectoryName, string destinationArchiveFileName, CompressionLevel compressionLevel, bool includeBaseDirectory, Encoding entryNameEncoding)
		{
			DoCreateFromDirectory(sourceDirectoryName, destinationArchiveFileName, compressionLevel, includeBaseDirectory, entryNameEncoding);
		}

		public static void ExtractToDirectory(string sourceArchiveFileName, string destinationDirectoryName)
		{
			ExtractToDirectory(sourceArchiveFileName, destinationDirectoryName, null);
		}

		public static void ExtractToDirectory(string sourceArchiveFileName, string destinationDirectoryName, Encoding entryNameEncoding)
		{
			if (sourceArchiveFileName == null)
			{
				throw new ArgumentNullException("sourceArchiveFileName");
			}
			using ZipArchive source = Open(sourceArchiveFileName, ZipArchiveMode.Read, entryNameEncoding);
			source.ExtractToDirectory(destinationDirectoryName);
		}

		private static void DoCreateFromDirectory(string sourceDirectoryName, string destinationArchiveFileName, CompressionLevel? compressionLevel, bool includeBaseDirectory, Encoding entryNameEncoding)
		{
			sourceDirectoryName = Path.GetFullPath(sourceDirectoryName);
			destinationArchiveFileName = Path.GetFullPath(destinationArchiveFileName);
			using ZipArchive zipArchive = Open(destinationArchiveFileName, ZipArchiveMode.Create, entryNameEncoding);
			bool flag = true;
			DirectoryInfo directoryInfo = new DirectoryInfo(sourceDirectoryName);
			string fullName = directoryInfo.FullName;
			if (includeBaseDirectory && directoryInfo.Parent != null)
			{
				fullName = directoryInfo.Parent.FullName;
			}
			foreach (FileSystemInfo item in directoryInfo.EnumerateFileSystemInfos("*", SearchOption.AllDirectories))
			{
				flag = false;
				int length = item.FullName.Length - fullName.Length;
				string text;
				if (System.LocalAppContextSwitches.ZipFileUseBackslash)
				{
					text = item.FullName.Substring(fullName.Length, length);
					text = text.TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
				}
				else
				{
					text = EntryFromPath(item.FullName, fullName.Length, length);
				}
				if (item is FileInfo)
				{
					ZipFileExtensions.DoCreateEntryFromFile(zipArchive, item.FullName, text, compressionLevel);
				}
				else if (item is DirectoryInfo possiblyEmptyDir && IsDirEmpty(possiblyEmptyDir))
				{
					string text2 = text;
					char c = s_pathSeperator;
					zipArchive.CreateEntry(text2 + c);
				}
			}
			if (includeBaseDirectory && flag)
			{
				string text = (System.LocalAppContextSwitches.ZipFileUseBackslash ? directoryInfo.Name : EntryFromPath(directoryInfo.Name, 0, directoryInfo.Name.Length));
				string text3 = text;
				char c = s_pathSeperator;
				zipArchive.CreateEntry(text3 + c);
			}
		}

		private static string EntryFromPath(string entry, int offset, int length)
		{
			while (length > 0 && (entry[offset] == Path.DirectorySeparatorChar || entry[offset] == Path.AltDirectorySeparatorChar))
			{
				offset++;
				length--;
			}
			if (length == 0)
			{
				return string.Empty;
			}
			char[] array = entry.ToCharArray(offset, length);
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i] == Path.DirectorySeparatorChar || array[i] == Path.AltDirectorySeparatorChar)
				{
					array[i] = s_pathSeperator;
				}
			}
			return new string(array);
		}

		private static bool IsDirEmpty(DirectoryInfo possiblyEmptyDir)
		{
			using (IEnumerator<FileSystemInfo> enumerator = possiblyEmptyDir.EnumerateFileSystemInfos("*", SearchOption.AllDirectories).GetEnumerator())
			{
				if (enumerator.MoveNext())
				{
					FileSystemInfo current = enumerator.Current;
					return false;
				}
			}
			return true;
		}
	}
	[EditorBrowsable(EditorBrowsableState.Never)]
	internal static class ZipFileExtensions
	{
		public static ZipArchiveEntry CreateEntryFromFile(this ZipArchive destination, string sourceFileName, string entryName)
		{
			return DoCreateEntryFromFile(destination, sourceFileName, entryName, null);
		}

		public static ZipArchiveEntry CreateEntryFromFile(this ZipArchive destination, string sourceFileName, string entryName, CompressionLevel compressionLevel)
		{
			return DoCreateEntryFromFile(destination, sourceFileName, entryName, compressionLevel);
		}

		public static void ExtractToDirectory(this ZipArchive source, string destinationDirectoryName)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (destinationDirectoryName == null)
			{
				throw new ArgumentNullException("destinationDirectoryName");
			}
			DirectoryInfo directoryInfo = Directory.CreateDirectory(destinationDirectoryName);
			string text = directoryInfo.FullName;
			if (!System.LocalAppContextSwitches.DoNotAddTrailingSeparator)
			{
				int length = text.Length;
				if (length != 0 && text[length - 1] != Path.DirectorySeparatorChar)
				{
					string text2 = text;
					char directorySeparatorChar = Path.DirectorySeparatorChar;
					text = text2 + directorySeparatorChar;
				}
			}
			foreach (ZipArchiveEntry entry in source.Entries)
			{
				string fullPath = Path.GetFullPath(Path.Combine(text, entry.FullName));
				if (!fullPath.StartsWith(text, StringComparison.OrdinalIgnoreCase))
				{
					throw new IOException(SR.GetString("IO_ExtractingResultsInOutside"));
				}
				if (Path.GetFileName(fullPath).Length == 0)
				{
					if (entry.Length != 0L)
					{
						throw new IOException(SR.GetString("IO_DirectoryNameWithData"));
					}
					Directory.CreateDirectory(fullPath);
				}
				else
				{
					Directory.CreateDirectory(Path.GetDirectoryName(fullPath));
					entry.ExtractToFile(fullPath, overwrite: false);
				}
			}
		}

		internal static ZipArchiveEntry DoCreateEntryFromFile(ZipArchive destination, string sourceFileName, string entryName, CompressionLevel? compressionLevel)
		{
			if (destination == null)
			{
				throw new ArgumentNullException("destination");
			}
			if (sourceFileName == null)
			{
				throw new ArgumentNullException("sourceFileName");
			}
			if (entryName == null)
			{
				throw new ArgumentNullException("entryName");
			}
			using Stream stream = File.Open(sourceFileName, FileMode.Open, FileAccess.Read, FileShare.Read);
			ZipArchiveEntry zipArchiveEntry = (compressionLevel.HasValue ? destination.CreateEntry(entryName, compressionLevel.Value) : destination.CreateEntry(entryName));
			DateTime dateTime = File.GetLastWriteTime(sourceFileName);
			if (dateTime.Year < 1980 || dateTime.Year > 2107)
			{
				dateTime = new DateTime(1980, 1, 1, 0, 0, 0);
			}
			zipArchiveEntry.LastWriteTime = dateTime;
			using (Stream destination2 = zipArchiveEntry.Open())
			{
				stream.CopyTo(destination2);
			}
			return zipArchiveEntry;
		}

		public static void ExtractToFile(this ZipArchiveEntry source, string destinationFileName)
		{
			source.ExtractToFile(destinationFileName, overwrite: false);
		}

		public static void ExtractToFile(this ZipArchiveEntry source, string destinationFileName, bool overwrite)
		{
			if (source == null)
			{
				throw new ArgumentNullException("source");
			}
			if (destinationFileName == null)
			{
				throw new ArgumentNullException("destinationFileName");
			}
			FileMode mode = ((!overwrite) ? FileMode.CreateNew : FileMode.Create);
			using (Stream destination = File.Open(destinationFileName, mode, FileAccess.Write, FileShare.None))
			{
				using Stream stream = source.Open();
				stream.CopyTo(destination);
			}
			File.SetLastWriteTime(destinationFileName, source.LastWriteTime.DateTime);
		}
	}
	internal sealed class SR
	{
		internal const string IO_DirectoryNameWithData = "IO_DirectoryNameWithData";

		internal const string IO_ExtractingResultsInOutside = "IO_ExtractingResultsInOutside";

		private static SR loader;

		private ResourceManager resources;

		private static CultureInfo Culture => null;

		public static ResourceManager Resources => GetLoader().resources;

		internal SR()
		{
			resources = new ResourceManager("System.IO.Compression.FileSystem", GetType().Assembly);
		}

		private static SR GetLoader()
		{
			if (loader == null)
			{
				SR value = new SR();
				Interlocked.CompareExchange(ref loader, value, null);
			}
			return loader;
		}

		public static string GetString(string name, params object[] args)
		{
			SR sR = GetLoader();
			if (sR == null)
			{
				return null;
			}
			string @string = sR.resources.GetString(name, Culture);
			if (args != null && args.Length != 0)
			{
				for (int i = 0; i < args.Length; i++)
				{
					if (args[i] is string text && text.Length > 1024)
					{
						args[i] = text.Substring(0, 1021) + "...";
					}
				}
				return string.Format(CultureInfo.CurrentCulture, @string, args);
			}
			return @string;
		}

		public static string GetString(string name)
		{
			return GetLoader()?.resources.GetString(name, Culture);
		}

		public static string GetString(string name, out bool usedFallback)
		{
			usedFallback = false;
			return GetString(name);
		}

		public static object GetObject(string name)
		{
			return GetLoader()?.resources.GetObject(name, Culture);
		}
	}
}
namespace FxResources.System.Buffers
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class <17450040-ccea-4f14-ac7e-804d699b5e2a>SR
	{
		private static ResourceManager s_resourceManager;

		private static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(ResourceType));

		internal static Type ResourceType { get; } = typeof(FxResources.System.Buffers.SR);


		internal static string ArgumentException_BufferNotFromPool => GetResourceString("ArgumentException_BufferNotFromPool", null);

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool UsingResourceKeys()
		{
			return false;
		}

		internal static string GetResourceString(string resourceKey, string defaultString)
		{
			string text = null;
			try
			{
				text = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			if (defaultString != null && resourceKey.Equals(text, StringComparison.Ordinal))
			{
				return defaultString;
			}
			return text;
		}

		internal static string Format(string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}
	}
}
namespace System.Buffers
{
	internal abstract class ArrayPool<T>
	{
		private static ArrayPool<T> s_sharedInstance;

		public static ArrayPool<T> Shared
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return Volatile.Read(ref s_sharedInstance) ?? EnsureSharedCreated();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static ArrayPool<T> EnsureSharedCreated()
		{
			Interlocked.CompareExchange(ref s_sharedInstance, Create(), null);
			return s_sharedInstance;
		}

		public static ArrayPool<T> Create()
		{
			return new DefaultArrayPool<T>();
		}

		public static ArrayPool<T> Create(int maxArrayLength, int maxArraysPerBucket)
		{
			return new DefaultArrayPool<T>(maxArrayLength, maxArraysPerBucket);
		}

		public abstract T[] Rent(int minimumLength);

		public abstract void Return(T[] array, bool clearArray = false);
	}
	[EventSource(Name = "System.Buffers.ArrayPoolEventSource")]
	internal sealed class ArrayPoolEventSource : EventSource
	{
		internal enum BufferAllocatedReason
		{
			Pooled,
			OverMaximumSize,
			PoolExhausted
		}

		internal static readonly System.Buffers.ArrayPoolEventSource Log = new System.Buffers.ArrayPoolEventSource();

		[Event(1, Level = EventLevel.Verbose)]
		internal unsafe void BufferRented(int bufferId, int bufferSize, int poolId, int bucketId)
		{
			EventData* ptr = stackalloc EventData[4];
			*ptr = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferId)
			};
			ptr[1] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferSize)
			};
			ptr[2] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&poolId)
			};
			ptr[3] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bucketId)
			};
			WriteEventCore(1, 4, ptr);
		}

		[Event(2, Level = EventLevel.Informational)]
		internal unsafe void BufferAllocated(int bufferId, int bufferSize, int poolId, int bucketId, BufferAllocatedReason reason)
		{
			EventData* ptr = stackalloc EventData[5];
			*ptr = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferId)
			};
			ptr[1] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bufferSize)
			};
			ptr[2] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&poolId)
			};
			ptr[3] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&bucketId)
			};
			ptr[4] = new EventData
			{
				Size = 4,
				DataPointer = (IntPtr)(&reason)
			};
			WriteEventCore(2, 5, ptr);
		}

		[Event(3, Level = EventLevel.Verbose)]
		internal void BufferReturned(int bufferId, int bufferSize, int poolId)
		{
			WriteEvent(3, bufferId, bufferSize, poolId);
		}
	}
	internal sealed class DefaultArrayPool<T> : ArrayPool<T>
	{
		private sealed class Bucket
		{
			internal readonly int _bufferLength;

			private readonly T[][] _buffers;

			private readonly int _poolId;

			private SpinLock _lock;

			private int _index;

			internal int Id => GetHashCode();

			internal Bucket(int bufferLength, int numberOfBuffers, int poolId)
			{
				_lock = new SpinLock(Debugger.IsAttached);
				_buffers = new T[numberOfBuffers][];
				_bufferLength = bufferLength;
				_poolId = poolId;
			}

			internal T[] Rent()
			{
				T[][] buffers = _buffers;
				T[] array = null;
				bool lockTaken = false;
				bool flag = false;
				try
				{
					_lock.Enter(ref lockTaken);
					if (_index < buffers.Length)
					{
						array = buffers[_index];
						buffers[_index++] = null;
						flag = array == null;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
				if (flag)
				{
					array = new T[_bufferLength];
					System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
					if (log.IsEnabled())
					{
						log.BufferAllocated(array.GetHashCode(), _bufferLength, _poolId, Id, System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.Pooled);
					}
				}
				return array;
			}

			internal void Return(T[] array)
			{
				if (array.Length != _bufferLength)
				{
					throw new ArgumentException(<17450040-ccea-4f14-ac7e-804d699b5e2a>SR.ArgumentException_BufferNotFromPool, "array");
				}
				bool lockTaken = false;
				try
				{
					_lock.Enter(ref lockTaken);
					if (_index != 0)
					{
						_buffers[--_index] = array;
					}
				}
				finally
				{
					if (lockTaken)
					{
						_lock.Exit(useMemoryBarrier: false);
					}
				}
			}
		}

		private const int DefaultMaxArrayLength = 1048576;

		private const int DefaultMaxNumberOfArraysPerBucket = 50;

		private static T[] s_emptyArray;

		private readonly Bucket[] _buckets;

		private int Id => GetHashCode();

		internal DefaultArrayPool()
			: this(1048576, 50)
		{
		}

		internal DefaultArrayPool(int maxArrayLength, int maxArraysPerBucket)
		{
			if (maxArrayLength <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArrayLength");
			}
			if (maxArraysPerBucket <= 0)
			{
				throw new ArgumentOutOfRangeException("maxArraysPerBucket");
			}
			if (maxArrayLength > 1073741824)
			{
				maxArrayLength = 1073741824;
			}
			else if (maxArrayLength < 16)
			{
				maxArrayLength = 16;
			}
			int id = Id;
			int num = System.Buffers.Utilities.SelectBucketIndex(maxArrayLength);
			Bucket[] array = new Bucket[num + 1];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = new Bucket(System.Buffers.Utilities.GetMaxSizeForBucket(i), maxArraysPerBucket, id);
			}
			_buckets = array;
		}

		public override T[] Rent(int minimumLength)
		{
			if (minimumLength < 0)
			{
				throw new ArgumentOutOfRangeException("minimumLength");
			}
			if (minimumLength == 0)
			{
				return s_emptyArray ?? (s_emptyArray = new T[0]);
			}
			System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
			T[] array = null;
			int num = System.Buffers.Utilities.SelectBucketIndex(minimumLength);
			if (num < _buckets.Length)
			{
				int num2 = num;
				do
				{
					array = _buckets[num2].Rent();
					if (array != null)
					{
						if (log.IsEnabled())
						{
							log.BufferRented(array.GetHashCode(), array.Length, Id, _buckets[num2].Id);
						}
						return array;
					}
				}
				while (++num2 < _buckets.Length && num2 != num + 2);
				array = new T[_buckets[num]._bufferLength];
			}
			else
			{
				array = new T[minimumLength];
			}
			if (log.IsEnabled())
			{
				int hashCode = array.GetHashCode();
				int bucketId = -1;
				log.BufferRented(hashCode, array.Length, Id, bucketId);
				log.BufferAllocated(hashCode, array.Length, Id, bucketId, (num >= _buckets.Length) ? System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.OverMaximumSize : System.Buffers.ArrayPoolEventSource.BufferAllocatedReason.PoolExhausted);
			}
			return array;
		}

		public override void Return(T[] array, bool clearArray = false)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Length == 0)
			{
				return;
			}
			int num = System.Buffers.Utilities.SelectBucketIndex(array.Length);
			if (num < _buckets.Length)
			{
				if (clearArray)
				{
					Array.Clear(array, 0, array.Length);
				}
				_buckets[num].Return(array);
			}
			System.Buffers.ArrayPoolEventSource log = System.Buffers.ArrayPoolEventSource.Log;
			if (log.IsEnabled())
			{
				log.BufferReturned(array.GetHashCode(), array.Length, Id);
			}
		}
	}
	internal static class Utilities
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int SelectBucketIndex(int bufferSize)
		{
			uint num = (uint)(bufferSize - 1) >> 4;
			int num2 = 0;
			if (num > 65535)
			{
				num >>= 16;
				num2 = 16;
			}
			if (num > 255)
			{
				num >>= 8;
				num2 += 8;
			}
			if (num > 15)
			{
				num >>= 4;
				num2 += 4;
			}
			if (num > 3)
			{
				num >>= 2;
				num2 += 2;
			}
			if (num > 1)
			{
				num >>= 1;
				num2++;
			}
			return num2 + (int)num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int GetMaxSizeForBucket(int binIndex)
		{
			return 16 << binIndex;
		}
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<8c256ab2-e3f1-4c40-853f-9b274b3bc2cf>Embedded]
	internal sealed class <8c256ab2-e3f1-4c40-853f-9b274b3bc2cf>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<8c256ab2-e3f1-4c40-853f-9b274b3bc2cf>Embedded]
	[CompilerGenerated]
	internal sealed class <4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnlyAttribute : Attribute
	{
	}
	[<8c256ab2-e3f1-4c40-853f-9b274b3bc2cf>Embedded]
	[CompilerGenerated]
	internal sealed class <f661f203-76f9-489e-a9bc-84db82730cde>IsByRefLikeAttribute : Attribute
	{
	}
}
namespace FxResources.System.Memory
{
	internal static class SR
	{
	}
}
namespace System
{
	[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
	internal struct SequencePosition : IEquatable<SequencePosition>
	{
		private readonly object _object;

		private readonly int _integer;

		public SequencePosition(object @object, int integer)
		{
			_object = @object;
			_integer = integer;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public object GetObject()
		{
			return _object;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public int GetInteger()
		{
			return _integer;
		}

		public bool Equals(SequencePosition other)
		{
			if (_integer == other._integer)
			{
				return object.Equals(_object, other._object);
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object obj)
		{
			if (obj is SequencePosition other)
			{
				return Equals(other);
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			return HashHelpers.Combine(_object?.GetHashCode() ?? 0, _integer);
		}
	}
	internal static class ThrowHelper
	{
		internal static void ThrowArgumentNullException(System.ExceptionArgument argument)
		{
			throw CreateArgumentNullException(argument);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentNullException(System.ExceptionArgument argument)
		{
			return new ArgumentNullException(argument.ToString());
		}

		internal static void ThrowArrayTypeMismatchException()
		{
			throw CreateArrayTypeMismatchException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArrayTypeMismatchException()
		{
			return new ArrayTypeMismatchException();
		}

		internal static void ThrowArgumentException_InvalidTypeWithPointersNotSupported(Type type)
		{
			throw CreateArgumentException_InvalidTypeWithPointersNotSupported(type);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentException_InvalidTypeWithPointersNotSupported(Type type)
		{
			return new ArgumentException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Format(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_InvalidTypeWithPointersNotSupported, type));
		}

		internal static void ThrowArgumentException_DestinationTooShort()
		{
			throw CreateArgumentException_DestinationTooShort();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentException_DestinationTooShort()
		{
			return new ArgumentException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_DestinationTooShort);
		}

		internal static void ThrowIndexOutOfRangeException()
		{
			throw CreateIndexOutOfRangeException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateIndexOutOfRangeException()
		{
			return new IndexOutOfRangeException();
		}

		internal static void ThrowArgumentOutOfRangeException()
		{
			throw CreateArgumentOutOfRangeException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentOutOfRangeException()
		{
			return new ArgumentOutOfRangeException();
		}

		internal static void ThrowArgumentOutOfRangeException(System.ExceptionArgument argument)
		{
			throw CreateArgumentOutOfRangeException(argument);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentOutOfRangeException(System.ExceptionArgument argument)
		{
			return new ArgumentOutOfRangeException(argument.ToString());
		}

		internal static void ThrowArgumentOutOfRangeException_PrecisionTooLarge()
		{
			throw CreateArgumentOutOfRangeException_PrecisionTooLarge();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentOutOfRangeException_PrecisionTooLarge()
		{
			return new ArgumentOutOfRangeException("precision", <2cdd3d99-010c-4688-b500-482730d0e75a>SR.Format(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_PrecisionTooLarge, (byte)99));
		}

		internal static void ThrowArgumentOutOfRangeException_SymbolDoesNotFit()
		{
			throw CreateArgumentOutOfRangeException_SymbolDoesNotFit();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentOutOfRangeException_SymbolDoesNotFit()
		{
			return new ArgumentOutOfRangeException("symbol", <2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_BadFormatSpecifier);
		}

		internal static void ThrowInvalidOperationException()
		{
			throw CreateInvalidOperationException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateInvalidOperationException()
		{
			return new InvalidOperationException();
		}

		internal static void ThrowInvalidOperationException_OutstandingReferences()
		{
			throw CreateInvalidOperationException_OutstandingReferences();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateInvalidOperationException_OutstandingReferences()
		{
			return new InvalidOperationException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.OutstandingReferences);
		}

		internal static void ThrowInvalidOperationException_UnexpectedSegmentType()
		{
			throw CreateInvalidOperationException_UnexpectedSegmentType();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateInvalidOperationException_UnexpectedSegmentType()
		{
			return new InvalidOperationException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.UnexpectedSegmentType);
		}

		internal static void ThrowInvalidOperationException_EndPositionNotReached()
		{
			throw CreateInvalidOperationException_EndPositionNotReached();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateInvalidOperationException_EndPositionNotReached()
		{
			return new InvalidOperationException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.EndPositionNotReached);
		}

		internal static void ThrowArgumentOutOfRangeException_PositionOutOfRange()
		{
			throw CreateArgumentOutOfRangeException_PositionOutOfRange();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentOutOfRangeException_PositionOutOfRange()
		{
			return new ArgumentOutOfRangeException("position");
		}

		internal static void ThrowArgumentOutOfRangeException_OffsetOutOfRange()
		{
			throw CreateArgumentOutOfRangeException_OffsetOutOfRange();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentOutOfRangeException_OffsetOutOfRange()
		{
			return new ArgumentOutOfRangeException("offset");
		}

		internal static void ThrowObjectDisposedException_ArrayMemoryPoolBuffer()
		{
			throw CreateObjectDisposedException_ArrayMemoryPoolBuffer();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateObjectDisposedException_ArrayMemoryPoolBuffer()
		{
			return new ObjectDisposedException("ArrayMemoryPoolBuffer");
		}

		internal static void ThrowFormatException_BadFormatSpecifier()
		{
			throw CreateFormatException_BadFormatSpecifier();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateFormatException_BadFormatSpecifier()
		{
			return new FormatException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_BadFormatSpecifier);
		}

		internal static void ThrowArgumentException_OverlapAlignmentMismatch()
		{
			throw CreateArgumentException_OverlapAlignmentMismatch();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateArgumentException_OverlapAlignmentMismatch()
		{
			return new ArgumentException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_OverlapAlignmentMismatch);
		}

		internal static void ThrowNotSupportedException()
		{
			throw CreateThrowNotSupportedException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static Exception CreateThrowNotSupportedException()
		{
			return new NotSupportedException();
		}

		public static bool TryFormatThrowFormatException(out int bytesWritten)
		{
			bytesWritten = 0;
			ThrowFormatException_BadFormatSpecifier();
			return false;
		}

		public static bool TryParseThrowFormatException<T>(out T value, out int bytesConsumed)
		{
			value = default(T);
			bytesConsumed = 0;
			ThrowFormatException_BadFormatSpecifier();
			return false;
		}

		public static void ThrowArgumentValidationException<T>(ReadOnlySequenceSegment<T> startSegment, int startIndex, ReadOnlySequenceSegment<T> endSegment)
		{
			throw CreateArgumentValidationException(startSegment, startIndex, endSegment);
		}

		private static Exception CreateArgumentValidationException<T>(ReadOnlySequenceSegment<T> startSegment, int startIndex, ReadOnlySequenceSegment<T> endSegment)
		{
			if (startSegment == null)
			{
				return CreateArgumentNullException(System.ExceptionArgument.startSegment);
			}
			if (endSegment == null)
			{
				return CreateArgumentNullException(System.ExceptionArgument.endSegment);
			}
			if (startSegment != endSegment && startSegment.RunningIndex > endSegment.RunningIndex)
			{
				return CreateArgumentOutOfRangeException(System.ExceptionArgument.endSegment);
			}
			if ((uint)startSegment.Memory.Length < (uint)startIndex)
			{
				return CreateArgumentOutOfRangeException(System.ExceptionArgument.startIndex);
			}
			return CreateArgumentOutOfRangeException(System.ExceptionArgument.endIndex);
		}

		public static void ThrowArgumentValidationException(Array array, int start)
		{
			throw CreateArgumentValidationException(array, start);
		}

		private static Exception CreateArgumentValidationException(Array array, int start)
		{
			if (array == null)
			{
				return CreateArgumentNullException(System.ExceptionArgument.array);
			}
			if ((uint)start > (uint)array.Length)
			{
				return CreateArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return CreateArgumentOutOfRangeException(System.ExceptionArgument.length);
		}

		public static void ThrowStartOrEndArgumentValidationException(long start)
		{
			throw CreateStartOrEndArgumentValidationException(start);
		}

		private static Exception CreateStartOrEndArgumentValidationException(long start)
		{
			if (start < 0)
			{
				return CreateArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return CreateArgumentOutOfRangeException(System.ExceptionArgument.length);
		}
	}
	internal enum ExceptionArgument
	{
		length,
		start,
		minimumBufferSize,
		elementIndex,
		comparable,
		comparer,
		destination,
		offset,
		startSegment,
		endSegment,
		startIndex,
		endIndex,
		array,
		culture,
		manager
	}
	internal static class DecimalDecCalc
	{
		private static uint D32DivMod1E9(uint hi32, ref uint lo32)
		{
			ulong num = ((ulong)hi32 << 32) | lo32;
			lo32 = (uint)(num / 1000000000);
			return (uint)(num % 1000000000);
		}

		internal static uint DecDivMod1E9(ref MutableDecimal value)
		{
			return D32DivMod1E9(D32DivMod1E9(D32DivMod1E9(0u, ref value.High), ref value.Mid), ref value.Low);
		}

		internal static void DecAddInt32(ref MutableDecimal value, uint i)
		{
			if (D32AddCarry(ref value.Low, i) && D32AddCarry(ref value.Mid, 1u))
			{
				D32AddCarry(ref value.High, 1u);
			}
		}

		private static bool D32AddCarry(ref uint value, uint i)
		{
			uint num = value;
			uint num2 = (value = num + i);
			if (num2 >= num)
			{
				return num2 < i;
			}
			return true;
		}

		internal static void DecMul10(ref MutableDecimal value)
		{
			MutableDecimal d = value;
			DecShiftLeft(ref value);
			DecShiftLeft(ref value);
			DecAdd(ref value, d);
			DecShiftLeft(ref value);
		}

		private static void DecShiftLeft(ref MutableDecimal value)
		{
			uint num = (((value.Low & 0x80000000u) != 0) ? 1u : 0u);
			uint num2 = (((value.Mid & 0x80000000u) != 0) ? 1u : 0u);
			value.Low <<= 1;
			value.Mid = (value.Mid << 1) | num;
			value.High = (value.High << 1) | num2;
		}

		private static void DecAdd(ref MutableDecimal value, MutableDecimal d)
		{
			if (D32AddCarry(ref value.Low, d.Low) && D32AddCarry(ref value.Mid, 1u))
			{
				D32AddCarry(ref value.High, 1u);
			}
			if (D32AddCarry(ref value.Mid, d.Mid))
			{
				D32AddCarry(ref value.High, 1u);
			}
			D32AddCarry(ref value.High, d.High);
		}
	}
	internal static class Number
	{
		private static class DoubleHelper
		{
			public unsafe static uint Exponent(double d)
			{
				return (*(uint*)((byte*)(&d) + 4) >> 20) & 0x7FFu;
			}

			public unsafe static ulong Mantissa(double d)
			{
				return *(uint*)(&d) | ((ulong)(uint)(*(int*)((byte*)(&d) + 4) & 0xFFFFF) << 32);
			}

			public unsafe static bool Sign(double d)
			{
				return *(uint*)((byte*)(&d) + 4) >> 31 != 0;
			}
		}

		internal const int DECIMAL_PRECISION = 29;

		private static readonly ulong[] s_rgval64Power10 = new ulong[30]
		{
			11529215046068469760uL, 14411518807585587200uL, 18014398509481984000uL, 11258999068426240000uL, 14073748835532800000uL, 17592186044416000000uL, 10995116277760000000uL, 13743895347200000000uL, 17179869184000000000uL, 10737418240000000000uL,
			13421772800000000000uL, 16777216000000000000uL, 10485760000000000000uL, 13107200000000000000uL, 16384000000000000000uL, 14757395258967641293uL, 11805916207174113035uL, 9444732965739290428uL, 15111572745182864686uL, 12089258196146291749uL,
			9671406556917033399uL, 15474250491067253438uL, 12379400392853802751uL, 9903520314283042201uL, 15845632502852867522uL, 12676506002282294018uL, 10141204801825835215uL, 16225927682921336344uL, 12980742146337069075uL, 10384593717069655260uL
		};

		private static readonly sbyte[] s_rgexp64Power10 = new sbyte[15]
		{
			4, 7, 10, 14, 17, 20, 24, 27, 30, 34,
			37, 40, 44, 47, 50
		};

		private static readonly ulong[] s_rgval64Power10By16 = new ulong[42]
		{
			10240000000000000000uL, 11368683772161602974uL, 12621774483536188886uL, 14012984643248170708uL, 15557538194652854266uL, 17272337110188889248uL, 9588073174409622172uL, 10644899600020376798uL, 11818212630765741798uL, 13120851772591970216uL,
			14567071740625403792uL, 16172698447808779622uL, 17955302187076837696uL, 9967194951097567532uL, 11065809325636130658uL, 12285516299433008778uL, 13639663065038175358uL, 15143067982934716296uL, 16812182738118149112uL, 9332636185032188787uL,
			10361307573072618722uL, 16615349947311448416uL, 14965776766268445891uL, 13479973333575319909uL, 12141680576410806707uL, 10936253623915059637uL, 9850501549098619819uL, 17745086042373215136uL, 15983352577617880260uL, 14396524142538228461uL,
			12967236152753103031uL, 11679847981112819795uL, 10520271803096747049uL, 9475818434452569218uL, 17070116948172427008uL, 15375394465392026135uL, 13848924157002783096uL, 12474001934591998882uL, 11235582092889474480uL, 10120112665365530972uL,
			18230774251475056952uL, 16420821625123739930uL
		};

		private static readonly short[] s_rgexp64Power10By16 = new short[21]
		{
			54, 107, 160, 213, 266, 319, 373, 426, 479, 532,
			585, 638, 691, 745, 798, 851, 904, 957, 1010, 1064,
			1117
		};

		public static void RoundNumber(ref NumberBuffer number, int pos)
		{
			Span<byte> digits = number.Digits;
			int i;
			for (i = 0; i < pos && digits[i] != 0; i++)
			{
			}
			if (i == pos && digits[i] >= 53)
			{
				while (i > 0 && digits[i - 1] == 57)
				{
					i--;
				}
				if (i > 0)
				{
					digits[i - 1]++;
				}
				else
				{
					number.Scale++;
					digits[0] = 49;
					i = 1;
				}
			}
			else
			{
				while (i > 0 && digits[i - 1] == 48)
				{
					i--;
				}
			}
			if (i == 0)
			{
				number.Scale = 0;
				number.IsNegative = false;
			}
			digits[i] = 0;
		}

		internal static bool NumberBufferToDouble(ref NumberBuffer number, out double value)
		{
			double num = NumberToDouble(ref number);
			uint num2 = DoubleHelper.Exponent(num);
			ulong num3 = DoubleHelper.Mantissa(num);
			switch (num2)
			{
			case 2047u:
				value = 0.0;
				return false;
			case 0u:
				if (num3 == 0L)
				{
					num = 0.0;
				}
				break;
			}
			value = num;
			return true;
		}

		public unsafe static bool NumberBufferToDecimal(ref NumberBuffer number, ref decimal value)
		{
			MutableDecimal source = default(MutableDecimal);
			byte* ptr = number.UnsafeDigits;
			int num = number.Scale;
			if (*ptr == 0)
			{
				if (num > 0)
				{
					num = 0;
				}
			}
			else
			{
				if (num > 29)
				{
					return false;
				}
				while ((num > 0 || (*ptr != 0 && num > -28)) && (source.High < 429496729 || (source.High == 429496729 && (source.Mid < 2576980377u || (source.Mid == 2576980377u && (source.Low < 2576980377u || (source.Low == 2576980377u && *ptr <= 53)))))))
				{
					DecimalDecCalc.DecMul10(ref source);
					if (*ptr != 0)
					{
						DecimalDecCalc.DecAddInt32(ref source, (uint)(*(ptr++) - 48));
					}
					num--;
				}
				if (*(ptr++) >= 53)
				{
					bool flag = true;
					if (*(ptr - 1) == 53 && *(ptr - 2) % 2 == 0)
					{
						int num2 = 20;
						while (*ptr == 48 && num2 != 0)
						{
							ptr++;
							num2--;
						}
						if (*ptr == 0 || num2 == 0)
						{
							flag = false;
						}
					}
					if (flag)
					{
						DecimalDecCalc.DecAddInt32(ref source, 1u);
						if ((source.High | source.Mid | source.Low) == 0)
						{
							source.High = 429496729u;
							source.Mid = 2576980377u;
							source.Low = 2576980378u;
							num++;
						}
					}
				}
			}
			if (num > 0)
			{
				return false;
			}
			if (num <= -29)
			{
				source.High = 0u;
				source.Low = 0u;
				source.Mid = 0u;
				source.Scale = 28;
			}
			else
			{
				source.Scale = -num;
			}
			source.IsNegative = number.IsNegative;
			value = Unsafe.As<MutableDecimal, decimal>(ref source);
			return true;
		}

		public static void DecimalToNumber(decimal value, ref NumberBuffer number)
		{
			ref MutableDecimal reference = ref Unsafe.As<decimal, MutableDecimal>(ref value);
			Span<byte> digits = number.Digits;
			number.IsNegative = reference.IsNegative;
			int num = 29;
			while ((reference.Mid != 0) | (reference.High != 0))
			{
				uint num2 = DecimalDecCalc.DecDivMod1E9(ref reference);
				for (int i = 0; i < 9; i++)
				{
					digits[--num] = (byte)(num2 % 10 + 48);
					num2 /= 10;
				}
			}
			for (uint num3 = reference.Low; num3 != 0; num3 /= 10)
			{
				digits[--num] = (byte)(num3 % 10 + 48);
			}
			int num4 = 29 - num;
			number.Scale = num4 - reference.Scale;
			Span<byte> digits2 = number.Digits;
			int index = 0;
			while (--num4 >= 0)
			{
				digits2[index++] = digits[num++];
			}
			digits2[index] = 0;
		}

		private static uint DigitsToInt(ReadOnlySpan<byte> digits, int count)
		{
			uint value;
			int bytesConsumed;
			bool flag = Utf8Parser.TryParse(digits.Slice(0, count), out value, out bytesConsumed, 'D');
			return value;
		}

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

		private static ulong Mul64Lossy(ulong a, ulong b, ref int pexp)
		{
			ulong num = Mul32x32To64((uint)(a >> 32), (uint)(b >> 32)) + (Mul32x32To64((uint)(a >> 32), (uint)b) >> 32) + (Mul32x32To64((uint)a, (uint)(b >> 32)) >> 32);
			if ((num & 0x8000000000000000uL) == 0L)
			{
				num <<= 1;
				pexp--;
			}
			return num;
		}

		private static int abs(int value)
		{
			if (value < 0)
			{
				return -value;
			}
			return value;
		}

		private unsafe static double NumberToDouble(ref NumberBuffer number)
		{
			ReadOnlySpan<byte> digits = number.Digits;
			int i = 0;
			int numDigits = number.NumDigits;
			int num = numDigits;
			for (; digits[i] == 48; i++)
			{
				num--;
			}
			if (num == 0)
			{
				return 0.0;
			}
			int num2 = Math.Min(num, 9);
			num -= num2;
			ulong num3 = DigitsToInt(digits, num2);
			if (num > 0)
			{
				num2 = Math.Min(num, 9);
				num -= num2;
				uint b = (uint)(s_rgval64Power10[num2 - 1] >> 64 - s_rgexp64Power10[num2 - 1]);
				num3 = Mul32x32To64((uint)num3, b) + DigitsToInt(digits.Slice(9), num2);
			}
			int num4 = number.Scale - (numDigits - num);
			int num5 = abs(num4);
			if (num5 >= 352)
			{
				ulong num6 = ((num4 > 0) ? 9218868437227405312uL : 0);
				if (number.IsNegative)
				{
					num6 |= 0x8000000000000000uL;
				}
				return *(double*)(&num6);
			}
			int pexp = 64;
			if ((num3 & 0xFFFFFFFF00000000uL) == 0L)
			{
				num3 <<= 32;
				pexp -= 32;
			}
			if ((num3 & 0xFFFF000000000000uL) == 0L)
			{
				num3 <<= 16;
				pexp -= 16;
			}
			if ((num3 & 0xFF00000000000000uL) == 0L)
			{
				num3 <<= 8;
				pexp -= 8;
			}
			if ((num3 & 0xF000000000000000uL) == 0L)
			{
				num3 <<= 4;
				pexp -= 4;
			}
			if ((num3 & 0xC000000000000000uL) == 0L)
			{
				num3 <<= 2;
				pexp -= 2;
			}
			if ((num3 & 0x8000000000000000uL) == 0L)
			{
				num3 <<= 1;
				pexp--;
			}
			int num7 = num5 & 0xF;
			if (num7 != 0)
			{
				int num8 = s_rgexp64Power10[num7 - 1];
				pexp += ((num4 < 0) ? (-num8 + 1) : num8);
				ulong b2 = s_rgval64Power10[num7 + ((num4 < 0) ? 15 : 0) - 1];
				num3 = Mul64Lossy(num3, b2, ref pexp);
			}
			num7 = num5 >> 4;
			if (num7 != 0)
			{
				int num9 = s_rgexp64Power10By16[num7 - 1];
				pexp += ((num4 < 0) ? (-num9 + 1) : num9);
				ulong b3 = s_rgval64Power10By16[num7 + ((num4 < 0) ? 21 : 0) - 1];
				num3 = Mul64Lossy(num3, b3, ref pexp);
			}
			if (((uint)(int)num3 & 0x400u) != 0)
			{
				ulong num10 = num3 + 1023 + (ulong)(((int)num3 >> 11) & 1);
				if (num10 < num3)
				{
					num10 = (num10 >> 1) | 0x8000000000000000uL;
					pexp++;
				}
				num3 = num10;
			}
			pexp += 1022;
			num3 = ((pexp <= 0) ? ((pexp == -52 && num3 >= 9223372036854775896uL) ? 1 : ((pexp > -52) ? (num3 >> -pexp + 11 + 1) : 0)) : ((pexp < 2047) ? ((ulong)((long)pexp << 52) + ((num3 >> 11) & 0xFFFFFFFFFFFFFL)) : 9218868437227405312uL));
			if (number.IsNegative)
			{
				num3 |= 0x8000000000000000uL;
			}
			return *(double*)(&num3);
		}
	}
	[<f661f203-76f9-489e-a9bc-84db82730cde>IsByRefLike]
	internal struct NumberBuffer
	{
		public int Scale;

		public bool IsNegative;

		public const int BufferSize = 51;

		private byte _b0;

		private byte _b1;

		private byte _b2;

		private byte _b3;

		private byte _b4;

		private byte _b5;

		private byte _b6;

		private byte _b7;

		private byte _b8;

		private byte _b9;

		private byte _b10;

		private byte _b11;

		private byte _b12;

		private byte _b13;

		private byte _b14;

		private byte _b15;

		private byte _b16;

		private byte _b17;

		private byte _b18;

		private byte _b19;

		private byte _b20;

		private byte _b21;

		private byte _b22;

		private byte _b23;

		private byte _b24;

		private byte _b25;

		private byte _b26;

		private byte _b27;

		private byte _b28;

		private byte _b29;

		private byte _b30;

		private byte _b31;

		private byte _b32;

		private byte _b33;

		private byte _b34;

		private byte _b35;

		private byte _b36;

		private byte _b37;

		private byte _b38;

		private byte _b39;

		private byte _b40;

		private byte _b41;

		private byte _b42;

		private byte _b43;

		private byte _b44;

		private byte _b45;

		private byte _b46;

		private byte _b47;

		private byte _b48;

		private byte _b49;

		private byte _b50;

		public unsafe Span<byte> Digits => new Span<byte>(Unsafe.AsPointer(ref _b0), 51);

		public unsafe byte* UnsafeDigits => (byte*)Unsafe.AsPointer(ref _b0);

		public int NumDigits => Digits.IndexOf<byte>(0);

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

		public override string ToString()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append('[');
			stringBuilder.Append('"');
			Span<byte> digits = Digits;
			for (int i = 0; i < 51; i++)
			{
				byte b = digits[i];
				if (b == 0)
				{
					break;
				}
				stringBuilder.Append((char)b);
			}
			stringBuilder.Append('"');
			stringBuilder.Append(", Scale = " + Scale);
			stringBuilder.Append(", IsNegative   = " + IsNegative);
			stringBuilder.Append(']');
			return stringBuilder.ToString();
		}
	}
	[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
	[DebuggerDisplay("{ToString(),raw}")]
	[DebuggerTypeProxy(typeof(System.MemoryDebugView<>))]
	internal struct Memory<T>
	{
		private readonly object _object;

		private readonly int _index;

		private readonly int _length;

		private const int RemoveFlagsBitMask = int.MaxValue;

		public static Memory<T> Empty => default(Memory<T>);

		public int Length => _length & 0x7FFFFFFF;

		public bool IsEmpty => (_length & 0x7FFFFFFF) == 0;

		public Span<T> Span
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (_index < 0)
				{
					return ((MemoryManager<T>)_object).GetSpan().Slice(_index & 0x7FFFFFFF, _length);
				}
				if (typeof(T) == typeof(char) && _object is string text)
				{
					return new Span<T>(Unsafe.As<Pinnable<T>>(text), MemoryExtensions.StringAdjustment, text.Length).Slice(_index, _length);
				}
				if (_object != null)
				{
					return new Span<T>((T[])_object, _index, _length & 0x7FFFFFFF);
				}
				return default(Span<T>);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory(T[] array)
		{
			if (array == null)
			{
				this = default(Memory<T>);
				return;
			}
			if (default(T) == null && array.GetType() != typeof(T[]))
			{
				System.ThrowHelper.ThrowArrayTypeMismatchException();
			}
			_object = array;
			_index = 0;
			_length = array.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(T[] array, int start)
		{
			if (array == null)
			{
				if (start != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(Memory<T>);
				return;
			}
			if (default(T) == null && array.GetType() != typeof(T[]))
			{
				System.ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = array;
			_index = start;
			_length = array.Length - start;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory(T[] array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(Memory<T>);
				return;
			}
			if (default(T) == null && array.GetType() != typeof(T[]))
			{
				System.ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = array;
			_index = start;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(MemoryManager<T> manager, int length)
		{
			if (length < 0)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = manager;
			_index = int.MinValue;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(MemoryManager<T> manager, int start, int length)
		{
			if (length < 0 || start < 0)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = manager;
			_index = start | int.MinValue;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Memory(object obj, int start, int length)
		{
			_object = obj;
			_index = start;
			_length = length;
		}

		public static implicit operator Memory<T>(T[] array)
		{
			return new Memory<T>(array);
		}

		public static implicit operator Memory<T>(ArraySegment<T> segment)
		{
			return new Memory<T>(segment.Array, segment.Offset, segment.Count);
		}

		public static implicit operator ReadOnlyMemory<T>(Memory<T> memory)
		{
			return Unsafe.As<Memory<T>, ReadOnlyMemory<T>>(ref memory);
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				if (!(_object is string text))
				{
					return Span.ToString();
				}
				return text.Substring(_index, _length & 0x7FFFFFFF);
			}
			return $"System.Memory<{typeof(T).Name}>[{_length & 0x7FFFFFFF}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory<T> Slice(int start)
		{
			int length = _length;
			int num = length & 0x7FFFFFFF;
			if ((uint)start > (uint)num)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new Memory<T>(_object, _index + start, length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Memory<T> Slice(int start, int length)
		{
			int length2 = _length;
			int num = length2 & 0x7FFFFFFF;
			if ((uint)start > (uint)num || (uint)length > (uint)(num - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Memory<T>(_object, _index + start, length | (length2 & int.MinValue));
		}

		public void CopyTo(Memory<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public unsafe MemoryHandle Pin()
		{
			if (_index < 0)
			{
				return ((MemoryManager<T>)_object).Pin(_index & 0x7FFFFFFF);
			}
			if (typeof(T) == typeof(char) && _object is string value)
			{
				GCHandle handle = GCHandle.Alloc(value, GCHandleType.Pinned);
				void* pointer = Unsafe.Add<T>((void*)handle.AddrOfPinnedObject(), _index);
				return new MemoryHandle(pointer, handle);
			}
			if (_object is T[] array)
			{
				if (_length < 0)
				{
					void* pointer2 = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetReference<T>(array)), _index);
					return new MemoryHandle(pointer2);
				}
				GCHandle handle2 = GCHandle.Alloc(array, GCHandleType.Pinned);
				void* pointer3 = Unsafe.Add<T>((void*)handle2.AddrOfPinnedObject(), _index);
				return new MemoryHandle(pointer3, handle2);
			}
			return default(MemoryHandle);
		}

		public T[] ToArray()
		{
			return Span.ToArray();
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object obj)
		{
			if (obj is ReadOnlyMemory<T> readOnlyMemory)
			{
				return readOnlyMemory.Equals(this);
			}
			if (obj is Memory<T> other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(Memory<T> other)
		{
			if (_object == other._object && _index == other._index)
			{
				return _length == other._length;
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			if (_object == null)
			{
				return 0;
			}
			int hashCode = _object.GetHashCode();
			int index = _index;
			int hashCode2 = index.GetHashCode();
			index = _length;
			return CombineHashCodes(hashCode, hashCode2, index.GetHashCode());
		}

		private static int CombineHashCodes(int left, int right)
		{
			return ((left << 5) + left) ^ right;
		}

		private static int CombineHashCodes(int h1, int h2, int h3)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2), h3);
		}
	}
	internal sealed class MemoryDebugView<T>
	{
		private readonly ReadOnlyMemory<T> _memory;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => _memory.ToArray();

		public MemoryDebugView(Memory<T> memory)
		{
			_memory = memory;
		}

		public MemoryDebugView(ReadOnlyMemory<T> memory)
		{
			_memory = memory;
		}
	}
	internal static class MemoryExtensions
	{
		internal static readonly IntPtr StringAdjustment = MeasureStringAdjustment();

		public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span)
		{
			return span.TrimStart().TrimEnd();
		}

		public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span)
		{
			int i;
			for (i = 0; i < span.Length && char.IsWhiteSpace(span[i]); i++)
			{
			}
			return span.Slice(i);
		}

		public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span)
		{
			int num = span.Length - 1;
			while (num >= 0 && char.IsWhiteSpace(span[num]))
			{
				num--;
			}
			return span.Slice(0, num + 1);
		}

		public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, char trimChar)
		{
			return span.TrimStart(trimChar).TrimEnd(trimChar);
		}

		public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, char trimChar)
		{
			int i;
			for (i = 0; i < span.Length && span[i] == trimChar; i++)
			{
			}
			return span.Slice(i);
		}

		public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, char trimChar)
		{
			int num = span.Length - 1;
			while (num >= 0 && span[num] == trimChar)
			{
				num--;
			}
			return span.Slice(0, num + 1);
		}

		public static ReadOnlySpan<char> Trim(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
		{
			return span.TrimStart(trimChars).TrimEnd(trimChars);
		}

		public static ReadOnlySpan<char> TrimStart(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
		{
			if (trimChars.IsEmpty)
			{
				return span.TrimStart();
			}
			int i;
			for (i = 0; i < span.Length; i++)
			{
				int num = 0;
				while (num < trimChars.Length)
				{
					if (span[i] != trimChars[num])
					{
						num++;
						continue;
					}
					goto IL_003c;
				}
				break;
				IL_003c:;
			}
			return span.Slice(i);
		}

		public static ReadOnlySpan<char> TrimEnd(this ReadOnlySpan<char> span, ReadOnlySpan<char> trimChars)
		{
			if (trimChars.IsEmpty)
			{
				return span.TrimEnd();
			}
			int num;
			for (num = span.Length - 1; num >= 0; num--)
			{
				int num2 = 0;
				while (num2 < trimChars.Length)
				{
					if (span[num] != trimChars[num2])
					{
						num2++;
						continue;
					}
					goto IL_0044;
				}
				break;
				IL_0044:;
			}
			return span.Slice(0, num + 1);
		}

		public static bool IsWhiteSpace(this ReadOnlySpan<char> span)
		{
			for (int i = 0; i < span.Length; i++)
			{
				if (!char.IsWhiteSpace(span[i]))
				{
					return false;
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.IndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
			}
			return System.SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
			}
			return System.SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this Span<T> span, T value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.LastIndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
			}
			return System.SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
			}
			return System.SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool SequenceEqual<T>(this Span<T> span, ReadOnlySpan<T> other) where T : IEquatable<T>
		{
			int length = span.Length;
			if (default(T) != null && IsTypeComparableAsBytes<T>(out var size))
			{
				if (length == other.Length)
				{
					return System.SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), (NUInt)length * size);
				}
				return false;
			}
			if (length == other.Length)
			{
				return System.SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other), length);
			}
			return false;
		}

		public static int SequenceCompareTo<T>(this Span<T> span, ReadOnlySpan<T> other) where T : IComparable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			return System.SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(other), other.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.IndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
			}
			return System.SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
			}
			return System.SpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this ReadOnlySpan<T> span, T value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value), span.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.LastIndexOf(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, char>(ref value), span.Length);
			}
			return System.SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), value, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOf<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOf(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), value.Length);
			}
			return System.SpanHelpers.LastIndexOf(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
			}
			return System.SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
			}
			return System.SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)), values.Length);
			}
			return System.SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
			}
			return System.SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
			}
			return System.SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int IndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.IndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)), values.Length);
			}
			return System.SpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
			}
			return System.SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this Span<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
			}
			return System.SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this Span<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)), values.Length);
			}
			return System.SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), span.Length);
			}
			return System.SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, T value0, T value1, T value2) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), Unsafe.As<T, byte>(ref value0), Unsafe.As<T, byte>(ref value1), Unsafe.As<T, byte>(ref value2), span.Length);
			}
			return System.SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), value0, value1, value2, span.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int LastIndexOfAny<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> values) where T : IEquatable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.LastIndexOfAny(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)), values.Length);
			}
			return System.SpanHelpers.LastIndexOfAny(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(values), values.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool SequenceEqual<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other) where T : IEquatable<T>
		{
			int length = span.Length;
			if (default(T) != null && IsTypeComparableAsBytes<T>(out var size))
			{
				if (length == other.Length)
				{
					return System.SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), (NUInt)length * size);
				}
				return false;
			}
			if (length == other.Length)
			{
				return System.SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other), length);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SequenceCompareTo<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other) where T : IComparable<T>
		{
			if (typeof(T) == typeof(byte))
			{
				return System.SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			if (typeof(T) == typeof(char))
			{
				return System.SpanHelpers.SequenceCompareTo(ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)), span.Length, ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(other)), other.Length);
			}
			return System.SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(other), other.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool StartsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = value.Length;
			if (default(T) != null && IsTypeComparableAsBytes<T>(out var size))
			{
				if (length <= span.Length)
				{
					return System.SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (NUInt)length * size);
				}
				return false;
			}
			if (length <= span.Length)
			{
				return System.SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), length);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool StartsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = value.Length;
			if (default(T) != null && IsTypeComparableAsBytes<T>(out var size))
			{
				if (length <= span.Length)
				{
					return System.SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (NUInt)length * size);
				}
				return false;
			}
			if (length <= span.Length)
			{
				return System.SpanHelpers.SequenceEqual(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(value), length);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EndsWith<T>(this Span<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = span.Length;
			int length2 = value.Length;
			if (default(T) != null && IsTypeComparableAsBytes<T>(out var size))
			{
				if (length2 <= length)
				{
					return System.SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), length - length2)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (NUInt)length2 * size);
				}
				return false;
			}
			if (length2 <= length)
			{
				return System.SpanHelpers.SequenceEqual(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), length - length2), ref MemoryMarshal.GetReference(value), length2);
			}
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool EndsWith<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> value) where T : IEquatable<T>
		{
			int length = span.Length;
			int length2 = value.Length;
			if (default(T) != null && IsTypeComparableAsBytes<T>(out var size))
			{
				if (length2 <= length)
				{
					return System.SpanHelpers.SequenceEqual(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), length - length2)), ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)), (NUInt)length2 * size);
				}
				return false;
			}
			if (length2 <= length)
			{
				return System.SpanHelpers.SequenceEqual(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), length - length2), ref MemoryMarshal.GetReference(value), length2);
			}
			return false;
		}

		public static void Reverse<T>(this Span<T> span)
		{
			ref T reference = ref MemoryMarshal.GetReference(span);
			int num = 0;
			int num2 = span.Length - 1;
			while (num < num2)
			{
				T val = Unsafe.Add(ref reference, num);
				Unsafe.Add(ref reference, num) = Unsafe.Add(ref reference, num2);
				Unsafe.Add(ref reference, num2) = val;
				num++;
				num2--;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[] array)
		{
			return new Span<T>(array);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this T[] array, int start, int length)
		{
			return new Span<T>(array, start, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment)
		{
			return new Span<T>(segment.Array, segment.Offset, segment.Count);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start)
		{
			if ((uint)start > segment.Count)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new Span<T>(segment.Array, segment.Offset + start, segment.Count - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<T> AsSpan<T>(this ArraySegment<T> segment, int start, int length)
		{
			if ((uint)start > segment.Count)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			if ((uint)length > segment.Count - start)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			return new Span<T>(segment.Array, segment.Offset + start, length);
		}

		public static Memory<T> AsMemory<T>(this T[] array)
		{
			return new Memory<T>(array);
		}

		public static Memory<T> AsMemory<T>(this T[] array, int start)
		{
			return new Memory<T>(array, start);
		}

		public static Memory<T> AsMemory<T>(this T[] array, int start, int length)
		{
			return new Memory<T>(array, start, length);
		}

		public static Memory<T> AsMemory<T>(this ArraySegment<T> segment)
		{
			return new Memory<T>(segment.Array, segment.Offset, segment.Count);
		}

		public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start)
		{
			if ((uint)start > segment.Count)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new Memory<T>(segment.Array, segment.Offset + start, segment.Count - start);
		}

		public static Memory<T> AsMemory<T>(this ArraySegment<T> segment, int start, int length)
		{
			if ((uint)start > segment.Count)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			if ((uint)length > segment.Count - start)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			return new Memory<T>(segment.Array, segment.Offset + start, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CopyTo<T>(this T[] source, Span<T> destination)
		{
			new ReadOnlySpan<T>(source).CopyTo(destination);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CopyTo<T>(this T[] source, Memory<T> destination)
		{
			source.CopyTo(destination.Span);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other)
		{
			return ((ReadOnlySpan<T>)span).Overlaps(other);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool Overlaps<T>(this Span<T> span, ReadOnlySpan<T> other, out int elementOffset)
		{
			return ((ReadOnlySpan<T>)span).Overlaps(other, out elementOffset);
		}

		public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other)
		{
			if (span.IsEmpty || other.IsEmpty)
			{
				return false;
			}
			IntPtr intPtr = Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other));
			if (Unsafe.SizeOf<IntPtr>() == 4)
			{
				if ((uint)(int)intPtr >= (uint)(span.Length * Unsafe.SizeOf<T>()))
				{
					return (uint)(int)intPtr > (uint)(-(other.Length * Unsafe.SizeOf<T>()));
				}
				return true;
			}
			if ((ulong)(long)intPtr >= (ulong)((long)span.Length * (long)Unsafe.SizeOf<T>()))
			{
				return (ulong)(long)intPtr > (ulong)(-((long)other.Length * (long)Unsafe.SizeOf<T>()));
			}
			return true;
		}

		public static bool Overlaps<T>(this ReadOnlySpan<T> span, ReadOnlySpan<T> other, out int elementOffset)
		{
			if (span.IsEmpty || other.IsEmpty)
			{
				elementOffset = 0;
				return false;
			}
			IntPtr intPtr = Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref MemoryMarshal.GetReference(other));
			if (Unsafe.SizeOf<IntPtr>() == 4)
			{
				if ((uint)(int)intPtr < (uint)(span.Length * Unsafe.SizeOf<T>()) || (uint)(int)intPtr > (uint)(-(other.Length * Unsafe.SizeOf<T>())))
				{
					if ((int)intPtr % Unsafe.SizeOf<T>() != 0)
					{
						System.ThrowHelper.ThrowArgumentException_OverlapAlignmentMismatch();
					}
					elementOffset = (int)intPtr / Unsafe.SizeOf<T>();
					return true;
				}
				elementOffset = 0;
				return false;
			}
			if ((ulong)(long)intPtr < (ulong)((long)span.Length * (long)Unsafe.SizeOf<T>()) || (ulong)(long)intPtr > (ulong)(-((long)other.Length * (long)Unsafe.SizeOf<T>())))
			{
				if ((long)intPtr % Unsafe.SizeOf<T>() != 0L)
				{
					System.ThrowHelper.ThrowArgumentException_OverlapAlignmentMismatch();
				}
				elementOffset = (int)((long)intPtr / Unsafe.SizeOf<T>());
				return true;
			}
			elementOffset = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T>(this Span<T> span, IComparable<T> comparable)
		{
			return span.BinarySearch<T, IComparable<T>>(comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparable>(this Span<T> span, TComparable comparable) where TComparable : IComparable<T>
		{
			return BinarySearch((ReadOnlySpan<T>)span, comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparer>(this Span<T> span, T value, TComparer comparer) where TComparer : IComparer<T>
		{
			return ((ReadOnlySpan<T>)span).BinarySearch(value, comparer);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T>(this ReadOnlySpan<T> span, IComparable<T> comparable)
		{
			return MemoryExtensions.BinarySearch<T, IComparable<T>>(span, comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparable>(this ReadOnlySpan<T> span, TComparable comparable) where TComparable : IComparable<T>
		{
			return System.SpanHelpers.BinarySearch(span, comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparer>(this ReadOnlySpan<T> span, T value, TComparer comparer) where TComparer : IComparer<T>
		{
			if (comparer == null)
			{
				System.ThrowHelper.ThrowArgumentNullException(System.ExceptionArgument.comparer);
			}
			System.SpanHelpers.ComparerComparable<T, TComparer> comparable = new System.SpanHelpers.ComparerComparable<T, TComparer>(value, comparer);
			return BinarySearch(span, comparable);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool IsTypeComparableAsBytes<T>(out NUInt size)
		{
			if (typeof(T) == typeof(byte) || typeof(T) == typeof(sbyte))
			{
				size = (NUInt)1;
				return true;
			}
			if (typeof(T) == typeof(char) || typeof(T) == typeof(short) || typeof(T) == typeof(ushort))
			{
				size = (NUInt)2;
				return true;
			}
			if (typeof(T) == typeof(int) || typeof(T) == typeof(uint))
			{
				size = (NUInt)4;
				return true;
			}
			if (typeof(T) == typeof(long) || typeof(T) == typeof(ulong))
			{
				size = (NUInt)8;
				return true;
			}
			size = default(NUInt);
			return false;
		}

		public static Span<T> AsSpan<T>(this T[] array, int start)
		{
			return Span<T>.Create(array, start);
		}

		public static bool Contains(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			return span.IndexOf(value, comparisonType) >= 0;
		}

		public static bool Equals(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.Ordinal:
				return span.SequenceEqual(other);
			case StringComparison.OrdinalIgnoreCase:
				if (span.Length != other.Length)
				{
					return false;
				}
				return EqualsOrdinalIgnoreCase(span, other);
			default:
				return span.ToString().Equals(other.ToString(), comparisonType);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool EqualsOrdinalIgnoreCase(ReadOnlySpan<char> span, ReadOnlySpan<char> other)
		{
			if (other.Length == 0)
			{
				return true;
			}
			return CompareToOrdinalIgnoreCase(span, other) == 0;
		}

		public static int CompareTo(this ReadOnlySpan<char> span, ReadOnlySpan<char> other, StringComparison comparisonType)
		{
			return comparisonType switch
			{
				StringComparison.Ordinal => span.SequenceCompareTo(other), 
				StringComparison.OrdinalIgnoreCase => CompareToOrdinalIgnoreCase(span, other), 
				_ => string.Compare(span.ToString(), other.ToString(), comparisonType), 
			};
		}

		private unsafe static int CompareToOrdinalIgnoreCase(ReadOnlySpan<char> strA, ReadOnlySpan<char> strB)
		{
			int num = Math.Min(strA.Length, strB.Length);
			int num2 = num;
			fixed (char* ptr = &MemoryMarshal.GetReference(strA))
			{
				fixed (char* ptr3 = &MemoryMarshal.GetReference(strB))
				{
					char* ptr2 = ptr;
					char* ptr4 = ptr3;
					while (num != 0 && *ptr2 <= '\u007f' && *ptr4 <= '\u007f')
					{
						int num3 = *ptr2;
						int num4 = *ptr4;
						if (num3 == num4)
						{
							ptr2++;
							ptr4++;
							num--;
							continue;
						}
						if ((uint)(num3 - 97) <= 25u)
						{
							num3 -= 32;
						}
						if ((uint)(num4 - 97) <= 25u)
						{
							num4 -= 32;
						}
						if (num3 != num4)
						{
							return num3 - num4;
						}
						ptr2++;
						ptr4++;
						num--;
					}
					if (num == 0)
					{
						return strA.Length - strB.Length;
					}
					num2 -= num;
					return string.Compare(strA.Slice(num2).ToString(), strB.Slice(num2).ToString(), StringComparison.OrdinalIgnoreCase);
				}
			}
		}

		public static int IndexOf(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			if (comparisonType == StringComparison.Ordinal)
			{
				return span.IndexOf(value);
			}
			return span.ToString().IndexOf(value.ToString(), comparisonType);
		}

		public static int ToLower(this ReadOnlySpan<char> source, Span<char> destination, CultureInfo culture)
		{
			if (culture == null)
			{
				System.ThrowHelper.ThrowArgumentNullException(System.ExceptionArgument.culture);
			}
			if (destination.Length < source.Length)
			{
				return -1;
			}
			string text = source.ToString();
			string text2 = text.ToLower(culture);
			AsSpan(text2).CopyTo(destination);
			return source.Length;
		}

		public static int ToLowerInvariant(this ReadOnlySpan<char> source, Span<char> destination)
		{
			return source.ToLower(destination, CultureInfo.InvariantCulture);
		}

		public static int ToUpper(this ReadOnlySpan<char> source, Span<char> destination, CultureInfo culture)
		{
			if (culture == null)
			{
				System.ThrowHelper.ThrowArgumentNullException(System.ExceptionArgument.culture);
			}
			if (destination.Length < source.Length)
			{
				return -1;
			}
			string text = source.ToString();
			string text2 = text.ToUpper(culture);
			AsSpan(text2).CopyTo(destination);
			return source.Length;
		}

		public static int ToUpperInvariant(this ReadOnlySpan<char> source, Span<char> destination)
		{
			return source.ToUpper(destination, CultureInfo.InvariantCulture);
		}

		public static bool EndsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.Ordinal:
				return span.EndsWith(value);
			case StringComparison.OrdinalIgnoreCase:
				if (value.Length <= span.Length)
				{
					return EqualsOrdinalIgnoreCase(span.Slice(span.Length - value.Length), value);
				}
				return false;
			default:
			{
				string text = span.ToString();
				string value2 = value.ToString();
				return text.EndsWith(value2, comparisonType);
			}
			}
		}

		public static bool StartsWith(this ReadOnlySpan<char> span, ReadOnlySpan<char> value, StringComparison comparisonType)
		{
			switch (comparisonType)
			{
			case StringComparison.Ordinal:
				return span.StartsWith(value);
			case StringComparison.OrdinalIgnoreCase:
				if (value.Length <= span.Length)
				{
					return EqualsOrdinalIgnoreCase(span.Slice(0, value.Length), value);
				}
				return false;
			default:
			{
				string text = span.ToString();
				string value2 = value.ToString();
				return text.StartsWith(value2, comparisonType);
			}
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> AsSpan(this string text)
		{
			if (text == null)
			{
				return default(ReadOnlySpan<char>);
			}
			return new ReadOnlySpan<char>(Unsafe.As<Pinnable<char>>(text), StringAdjustment, text.Length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> AsSpan(this string text, int start)
		{
			if (text == null)
			{
				if (start != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				return default(ReadOnlySpan<char>);
			}
			if ((uint)start > (uint)text.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new ReadOnlySpan<char>(Unsafe.As<Pinnable<char>>(text), StringAdjustment + start * 2, text.Length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<char> AsSpan(this string text, int start, int length)
		{
			if (text == null)
			{
				if (start != 0 || length != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				return default(ReadOnlySpan<char>);
			}
			if ((uint)start > (uint)text.Length || (uint)length > (uint)(text.Length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new ReadOnlySpan<char>(Unsafe.As<Pinnable<char>>(text), StringAdjustment + start * 2, length);
		}

		public static ReadOnlyMemory<char> AsMemory(this string text)
		{
			if (text == null)
			{
				return default(ReadOnlyMemory<char>);
			}
			return new ReadOnlyMemory<char>(text, 0, text.Length);
		}

		public static ReadOnlyMemory<char> AsMemory(this string text, int start)
		{
			if (text == null)
			{
				if (start != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				return default(ReadOnlyMemory<char>);
			}
			if ((uint)start > (uint)text.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new ReadOnlyMemory<char>(text, start, text.Length - start);
		}

		public static ReadOnlyMemory<char> AsMemory(this string text, int start, int length)
		{
			if (text == null)
			{
				if (start != 0 || length != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				return default(ReadOnlyMemory<char>);
			}
			if ((uint)start > (uint)text.Length || (uint)length > (uint)(text.Length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new ReadOnlyMemory<char>(text, start, length);
		}

		private unsafe static IntPtr MeasureStringAdjustment()
		{
			string text = "a";
			fixed (char* source = text)
			{
				return Unsafe.ByteOffset(ref Unsafe.As<Pinnable<char>>(text).Data, ref Unsafe.AsRef<char>(source));
			}
		}
	}
	[DebuggerTypeProxy(typeof(System.MemoryDebugView<>))]
	[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
	[DebuggerDisplay("{ToString(),raw}")]
	internal struct ReadOnlyMemory<T>
	{
		private readonly object _object;

		private readonly int _index;

		private readonly int _length;

		internal const int RemoveFlagsBitMask = int.MaxValue;

		public static ReadOnlyMemory<T> Empty => default(ReadOnlyMemory<T>);

		public int Length => _length & 0x7FFFFFFF;

		public bool IsEmpty => (_length & 0x7FFFFFFF) == 0;

		public ReadOnlySpan<T> Span
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if (_index < 0)
				{
					return ((MemoryManager<T>)_object).GetSpan().Slice(_index & 0x7FFFFFFF, _length);
				}
				if (typeof(T) == typeof(char) && _object is string text)
				{
					return new ReadOnlySpan<T>(Unsafe.As<Pinnable<T>>(text), MemoryExtensions.StringAdjustment, text.Length).Slice(_index, _length);
				}
				if (_object != null)
				{
					return new ReadOnlySpan<T>((T[])_object, _index, _length & 0x7FFFFFFF);
				}
				return default(ReadOnlySpan<T>);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory(T[] array)
		{
			if (array == null)
			{
				this = default(ReadOnlyMemory<T>);
				return;
			}
			_object = array;
			_index = 0;
			_length = array.Length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory(T[] array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				this = default(ReadOnlyMemory<T>);
				return;
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			_object = array;
			_index = start;
			_length = length;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ReadOnlyMemory(object obj, int start, int length)
		{
			_object = obj;
			_index = start;
			_length = length;
		}

		public static implicit operator ReadOnlyMemory<T>(T[] array)
		{
			return new ReadOnlyMemory<T>(array);
		}

		public static implicit operator ReadOnlyMemory<T>(ArraySegment<T> segment)
		{
			return new ReadOnlyMemory<T>(segment.Array, segment.Offset, segment.Count);
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				if (!(_object is string text))
				{
					return Span.ToString();
				}
				return text.Substring(_index, _length & 0x7FFFFFFF);
			}
			return $"System.ReadOnlyMemory<{typeof(T).Name}>[{_length & 0x7FFFFFFF}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory<T> Slice(int start)
		{
			int length = _length;
			int num = length & 0x7FFFFFFF;
			if ((uint)start > (uint)num)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new ReadOnlyMemory<T>(_object, _index + start, length - start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlyMemory<T> Slice(int start, int length)
		{
			int length2 = _length;
			int num = _length & 0x7FFFFFFF;
			if ((uint)start > (uint)num || (uint)length > (uint)(num - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			return new ReadOnlyMemory<T>(_object, _index + start, length | (length2 & int.MinValue));
		}

		public void CopyTo(Memory<T> destination)
		{
			Span.CopyTo(destination.Span);
		}

		public bool TryCopyTo(Memory<T> destination)
		{
			return Span.TryCopyTo(destination.Span);
		}

		public unsafe MemoryHandle Pin()
		{
			if (_index < 0)
			{
				return ((MemoryManager<T>)_object).Pin(_index & 0x7FFFFFFF);
			}
			if (typeof(T) == typeof(char) && _object is string value)
			{
				GCHandle handle = GCHandle.Alloc(value, GCHandleType.Pinned);
				void* pointer = Unsafe.Add<T>((void*)handle.AddrOfPinnedObject(), _index);
				return new MemoryHandle(pointer, handle);
			}
			if (_object is T[] array)
			{
				if (_length < 0)
				{
					void* pointer2 = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetReference<T>(array)), _index);
					return new MemoryHandle(pointer2);
				}
				GCHandle handle2 = GCHandle.Alloc(array, GCHandleType.Pinned);
				void* pointer3 = Unsafe.Add<T>((void*)handle2.AddrOfPinnedObject(), _index);
				return new MemoryHandle(pointer3, handle2);
			}
			return default(MemoryHandle);
		}

		public T[] ToArray()
		{
			return Span.ToArray();
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object obj)
		{
			if (obj is ReadOnlyMemory<T> other)
			{
				return Equals(other);
			}
			if (obj is Memory<T> memory)
			{
				return Equals(memory);
			}
			return false;
		}

		public bool Equals(ReadOnlyMemory<T> other)
		{
			if (_object == other._object && _index == other._index)
			{
				return _length == other._length;
			}
			return false;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public override int GetHashCode()
		{
			if (_object == null)
			{
				return 0;
			}
			int hashCode = _object.GetHashCode();
			int index = _index;
			int hashCode2 = index.GetHashCode();
			index = _length;
			return CombineHashCodes(hashCode, hashCode2, index.GetHashCode());
		}

		private static int CombineHashCodes(int left, int right)
		{
			return ((left << 5) + left) ^ right;
		}

		private static int CombineHashCodes(int h1, int h2, int h3)
		{
			return CombineHashCodes(CombineHashCodes(h1, h2), h3);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal object GetObjectStartLength(out int start, out int length)
		{
			start = _index;
			length = _length;
			return _object;
		}
	}
	[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	[<f661f203-76f9-489e-a9bc-84db82730cde>IsByRefLike]
	internal struct ReadOnlySpan<T>
	{
		[<f661f203-76f9-489e-a9bc-84db82730cde>IsByRefLike]
		public struct Enumerator
		{
			private readonly ReadOnlySpan<T> _span;

			private int _index;

			[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
			public ref T Current
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				[return: <4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
				get
				{
					return ref _span[_index];
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal Enumerator(ReadOnlySpan<T> span)
			{
				_span = span;
				_index = -1;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool MoveNext()
			{
				int num = _index + 1;
				if (num < _span.Length)
				{
					_index = num;
					return true;
				}
				return false;
			}
		}

		private readonly Pinnable<T> _pinnable;

		private readonly IntPtr _byteOffset;

		private readonly int _length;

		public int Length => _length;

		public bool IsEmpty => _length == 0;

		public static ReadOnlySpan<T> Empty => default(ReadOnlySpan<T>);

		[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
		public unsafe ref T this[int index]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			[return: <4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
			get
			{
				if ((uint)index >= (uint)_length)
				{
					System.ThrowHelper.ThrowIndexOutOfRangeException();
				}
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					return ref Unsafe.Add(ref Unsafe.AsRef<T>(byteOffset.ToPointer()), index);
				}
				return ref Unsafe.Add(ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset), index);
			}
		}

		internal Pinnable<T> Pinnable => _pinnable;

		internal IntPtr ByteOffset => _byteOffset;

		public static bool operator !=(ReadOnlySpan<T> left, ReadOnlySpan<T> right)
		{
			return !(left == right);
		}

		[Obsolete("Equals() on ReadOnlySpan will always throw an exception. Use == instead.")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public override bool Equals(object obj)
		{
			throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.NotSupported_CannotCallEqualsOnSpan);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("GetHashCode() on ReadOnlySpan will always throw an exception.")]
		public override int GetHashCode()
		{
			throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.NotSupported_CannotCallGetHashCodeOnSpan);
		}

		public static implicit operator ReadOnlySpan<T>(T[] array)
		{
			return new ReadOnlySpan<T>(array);
		}

		public static implicit operator ReadOnlySpan<T>(ArraySegment<T> segment)
		{
			return new ReadOnlySpan<T>(segment.Array, segment.Offset, segment.Count);
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan(T[] array)
		{
			if (array == null)
			{
				this = default(ReadOnlySpan<T>);
				return;
			}
			_length = array.Length;
			_pinnable = Unsafe.As<Pinnable<T>>(array);
			_byteOffset = System.SpanHelpers.PerTypeValues<T>.ArrayAdjustment;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan(T[] array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				this = default(ReadOnlySpan<T>);
				return;
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			_length = length;
			_pinnable = Unsafe.As<Pinnable<T>>(array);
			_byteOffset = System.SpanHelpers.PerTypeValues<T>.ArrayAdjustment.Add<T>(start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public unsafe ReadOnlySpan(void* pointer, int length)
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (length < 0)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			_length = length;
			_pinnable = null;
			_byteOffset = new IntPtr(pointer);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal ReadOnlySpan(Pinnable<T> pinnable, IntPtr byteOffset, int length)
		{
			_length = length;
			_pinnable = pinnable;
			_byteOffset = byteOffset;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[return: <4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
		public unsafe ref T GetPinnableReference()
		{
			if (_length != 0)
			{
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					return ref Unsafe.AsRef<T>(byteOffset.ToPointer());
				}
				return ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset);
			}
			return ref Unsafe.AsRef<T>(null);
		}

		public void CopyTo(Span<T> destination)
		{
			if (!TryCopyTo(destination))
			{
				System.ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
		}

		public bool TryCopyTo(Span<T> destination)
		{
			int length = _length;
			int length2 = destination.Length;
			if (length == 0)
			{
				return true;
			}
			if ((uint)length > (uint)length2)
			{
				return false;
			}
			ref T src = ref DangerousGetPinnableReference();
			System.SpanHelpers.CopyTo(ref destination.DangerousGetPinnableReference(), length2, ref src, length);
			return true;
		}

		public static bool operator ==(ReadOnlySpan<T> left, ReadOnlySpan<T> right)
		{
			if (left._length == right._length)
			{
				return Unsafe.AreSame(ref left.DangerousGetPinnableReference(), ref right.DangerousGetPinnableReference());
			}
			return false;
		}

		public unsafe override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				if (_byteOffset == MemoryExtensions.StringAdjustment)
				{
					object obj = Unsafe.As<object>(_pinnable);
					if (obj is string text && _length == text.Length)
					{
						return text;
					}
				}
				fixed (char* value = &Unsafe.As<T, char>(ref DangerousGetPinnableReference()))
				{
					return new string(value, 0, _length);
				}
			}
			return $"System.ReadOnlySpan<{typeof(T).Name}>[{_length}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<T> Slice(int start)
		{
			if ((uint)start > (uint)_length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			IntPtr byteOffset = _byteOffset.Add<T>(start);
			int length = _length - start;
			return new ReadOnlySpan<T>(_pinnable, byteOffset, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySpan<T> Slice(int start, int length)
		{
			if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			IntPtr byteOffset = _byteOffset.Add<T>(start);
			return new ReadOnlySpan<T>(_pinnable, byteOffset, length);
		}

		public T[] ToArray()
		{
			if (_length == 0)
			{
				return System.SpanHelpers.PerTypeValues<T>.EmptyArray;
			}
			T[] array = new T[_length];
			CopyTo(array);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		internal unsafe ref T DangerousGetPinnableReference()
		{
			if (_pinnable == null)
			{
				IntPtr byteOffset = _byteOffset;
				return ref Unsafe.AsRef<T>(byteOffset.ToPointer());
			}
			return ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset);
		}
	}
	[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	[DebuggerDisplay("{ToString(),raw}")]
	[DebuggerTypeProxy(typeof(System.SpanDebugView<>))]
	[<f661f203-76f9-489e-a9bc-84db82730cde>IsByRefLike]
	internal struct Span<T>
	{
		[<f661f203-76f9-489e-a9bc-84db82730cde>IsByRefLike]
		public struct Enumerator
		{
			private readonly Span<T> _span;

			private int _index;

			public ref T Current
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return ref _span[_index];
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal Enumerator(Span<T> span)
			{
				_span = span;
				_index = -1;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool MoveNext()
			{
				int num = _index + 1;
				if (num < _span.Length)
				{
					_index = num;
					return true;
				}
				return false;
			}
		}

		private readonly Pinnable<T> _pinnable;

		private readonly IntPtr _byteOffset;

		private readonly int _length;

		public int Length => _length;

		public bool IsEmpty => _length == 0;

		public static Span<T> Empty => default(Span<T>);

		public unsafe ref T this[int index]
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				if ((uint)index >= (uint)_length)
				{
					System.ThrowHelper.ThrowIndexOutOfRangeException();
				}
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					return ref Unsafe.Add(ref Unsafe.AsRef<T>(byteOffset.ToPointer()), index);
				}
				return ref Unsafe.Add(ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset), index);
			}
		}

		internal Pinnable<T> Pinnable => _pinnable;

		internal IntPtr ByteOffset => _byteOffset;

		public static bool operator !=(Span<T> left, Span<T> right)
		{
			return !(left == right);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("Equals() on Span will always throw an exception. Use == instead.")]
		public override bool Equals(object obj)
		{
			throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.NotSupported_CannotCallEqualsOnSpan);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Obsolete("GetHashCode() on Span will always throw an exception.")]
		public override int GetHashCode()
		{
			throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.NotSupported_CannotCallGetHashCodeOnSpan);
		}

		public static implicit operator Span<T>(T[] array)
		{
			return new Span<T>(array);
		}

		public static implicit operator Span<T>(ArraySegment<T> segment)
		{
			return new Span<T>(segment.Array, segment.Offset, segment.Count);
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span(T[] array)
		{
			if (array == null)
			{
				this = default(Span<T>);
				return;
			}
			if (default(T) == null && array.GetType() != typeof(T[]))
			{
				System.ThrowHelper.ThrowArrayTypeMismatchException();
			}
			_length = array.Length;
			_pinnable = Unsafe.As<Pinnable<T>>(array);
			_byteOffset = System.SpanHelpers.PerTypeValues<T>.ArrayAdjustment;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static Span<T> Create(T[] array, int start)
		{
			if (array == null)
			{
				if (start != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				return default(Span<T>);
			}
			if (default(T) == null && array.GetType() != typeof(T[]))
			{
				System.ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			IntPtr byteOffset = System.SpanHelpers.PerTypeValues<T>.ArrayAdjustment.Add<T>(start);
			int length = array.Length - start;
			return new Span<T>(Unsafe.As<Pinnable<T>>(array), byteOffset, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span(T[] array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				this = default(Span<T>);
				return;
			}
			if (default(T) == null && array.GetType() != typeof(T[]))
			{
				System.ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			_length = length;
			_pinnable = Unsafe.As<Pinnable<T>>(array);
			_byteOffset = System.SpanHelpers.PerTypeValues<T>.ArrayAdjustment.Add<T>(start);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public unsafe Span(void* pointer, int length)
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (length < 0)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			_length = length;
			_pinnable = null;
			_byteOffset = new IntPtr(pointer);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal Span(Pinnable<T> pinnable, IntPtr byteOffset, int length)
		{
			_length = length;
			_pinnable = pinnable;
			_byteOffset = byteOffset;
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		public unsafe ref T GetPinnableReference()
		{
			if (_length != 0)
			{
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					return ref Unsafe.AsRef<T>(byteOffset.ToPointer());
				}
				return ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset);
			}
			return ref Unsafe.AsRef<T>(null);
		}

		public unsafe void Clear()
		{
			int length = _length;
			if (length == 0)
			{
				return;
			}
			UIntPtr byteLength = (UIntPtr)(ulong)((uint)length * Unsafe.SizeOf<T>());
			if ((Unsafe.SizeOf<T>() & (sizeof(IntPtr) - 1)) != 0)
			{
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					byte* ptr = (byte*)byteOffset.ToPointer();
					System.SpanHelpers.ClearLessThanPointerSized(ptr, byteLength);
				}
				else
				{
					System.SpanHelpers.ClearLessThanPointerSized(ref Unsafe.As<T, byte>(ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset)), byteLength);
				}
			}
			else if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				UIntPtr pointerSizeLength = (UIntPtr)(ulong)(length * Unsafe.SizeOf<T>() / sizeof(IntPtr));
				System.SpanHelpers.ClearPointerSizedWithReferences(ref Unsafe.As<T, IntPtr>(ref DangerousGetPinnableReference()), pointerSizeLength);
			}
			else
			{
				System.SpanHelpers.ClearPointerSizedWithoutReferences(ref Unsafe.As<T, byte>(ref DangerousGetPinnableReference()), byteLength);
			}
		}

		public unsafe void Fill(T value)
		{
			int length = _length;
			if (length == 0)
			{
				return;
			}
			if (Unsafe.SizeOf<T>() == 1)
			{
				byte value2 = Unsafe.As<T, byte>(ref value);
				if (_pinnable == null)
				{
					IntPtr byteOffset = _byteOffset;
					Unsafe.InitBlockUnaligned(byteOffset.ToPointer(), value2, (uint)length);
				}
				else
				{
					Unsafe.InitBlockUnaligned(ref Unsafe.As<T, byte>(ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset)), value2, (uint)length);
				}
				return;
			}
			ref T source = ref DangerousGetPinnableReference();
			int i;
			for (i = 0; i < (length & -8); i += 8)
			{
				Unsafe.Add(ref source, i) = value;
				Unsafe.Add(ref source, i + 1) = value;
				Unsafe.Add(ref source, i + 2) = value;
				Unsafe.Add(ref source, i + 3) = value;
				Unsafe.Add(ref source, i + 4) = value;
				Unsafe.Add(ref source, i + 5) = value;
				Unsafe.Add(ref source, i + 6) = value;
				Unsafe.Add(ref source, i + 7) = value;
			}
			if (i < (length & -4))
			{
				Unsafe.Add(ref source, i) = value;
				Unsafe.Add(ref source, i + 1) = value;
				Unsafe.Add(ref source, i + 2) = value;
				Unsafe.Add(ref source, i + 3) = value;
				i += 4;
			}
			for (; i < length; i++)
			{
				Unsafe.Add(ref source, i) = value;
			}
		}

		public void CopyTo(Span<T> destination)
		{
			if (!TryCopyTo(destination))
			{
				System.ThrowHelper.ThrowArgumentException_DestinationTooShort();
			}
		}

		public bool TryCopyTo(Span<T> destination)
		{
			int length = _length;
			int length2 = destination._length;
			if (length == 0)
			{
				return true;
			}
			if ((uint)length > (uint)length2)
			{
				return false;
			}
			ref T src = ref DangerousGetPinnableReference();
			System.SpanHelpers.CopyTo(ref destination.DangerousGetPinnableReference(), length2, ref src, length);
			return true;
		}

		public static bool operator ==(Span<T> left, Span<T> right)
		{
			if (left._length == right._length)
			{
				return Unsafe.AreSame(ref left.DangerousGetPinnableReference(), ref right.DangerousGetPinnableReference());
			}
			return false;
		}

		public static implicit operator ReadOnlySpan<T>(Span<T> span)
		{
			return new ReadOnlySpan<T>(span._pinnable, span._byteOffset, span._length);
		}

		public unsafe override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				fixed (char* value = &Unsafe.As<T, char>(ref DangerousGetPinnableReference()))
				{
					return new string(value, 0, _length);
				}
			}
			return $"System.Span<{typeof(T).Name}>[{_length}]";
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span<T> Slice(int start)
		{
			if ((uint)start > (uint)_length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			IntPtr byteOffset = _byteOffset.Add<T>(start);
			int length = _length - start;
			return new Span<T>(_pinnable, byteOffset, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public Span<T> Slice(int start, int length)
		{
			if ((uint)start > (uint)_length || (uint)length > (uint)(_length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
			}
			IntPtr byteOffset = _byteOffset.Add<T>(start);
			return new Span<T>(_pinnable, byteOffset, length);
		}

		public T[] ToArray()
		{
			if (_length == 0)
			{
				return System.SpanHelpers.PerTypeValues<T>.EmptyArray;
			}
			T[] array = new T[_length];
			CopyTo(array);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		internal unsafe ref T DangerousGetPinnableReference()
		{
			if (_pinnable == null)
			{
				IntPtr byteOffset = _byteOffset;
				return ref Unsafe.AsRef<T>(byteOffset.ToPointer());
			}
			return ref Unsafe.AddByteOffset(ref _pinnable.Data, _byteOffset);
		}
	}
	internal sealed class SpanDebugView<T>
	{
		private readonly T[] _array;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => _array;

		public SpanDebugView(Span<T> span)
		{
			_array = span.ToArray();
		}

		public SpanDebugView(ReadOnlySpan<T> span)
		{
			_array = span.ToArray();
		}
	}
	internal static class SpanHelpers
	{
		internal struct ComparerComparable<T, TComparer> : IComparable<T> where TComparer : IComparer<T>
		{
			private readonly T _value;

			private readonly TComparer _comparer;

			public ComparerComparable(T value, TComparer comparer)
			{
				_value = value;
				_comparer = comparer;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public int CompareTo(T other)
			{
				return _comparer.Compare(_value, other);
			}
		}

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

		[StructLayout(LayoutKind.Sequential, Size = 32)]
		private struct Reg32
		{
		}

		[StructLayout(LayoutKind.Sequential, Size = 16)]
		private struct Reg16
		{
		}

		public static class PerTypeValues<T>
		{
			public static readonly bool IsReferenceOrContainsReferences = IsReferenceOrContainsReferencesCore(typeof(T));

			public static readonly T[] EmptyArray = new T[0];

			public static readonly IntPtr ArrayAdjustment = MeasureArrayAdjustment();

			private static IntPtr MeasureArrayAdjustment()
			{
				T[] array = new T[1];
				return Unsafe.ByteOffset(ref Unsafe.As<Pinnable<T>>(array).Data, ref array[0]);
			}
		}

		private const ulong XorPowerOfTwoToHighByte = 283686952306184uL;

		private const ulong XorPowerOfTwoToHighChar = 4295098372uL;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int BinarySearch<T, TComparable>(this ReadOnlySpan<T> span, TComparable comparable) where TComparable : IComparable<T>
		{
			if (comparable == null)
			{
				System.ThrowHelper.ThrowArgumentNullException(System.ExceptionArgument.comparable);
			}
			return BinarySearch(ref MemoryMarshal.GetReference(span), span.Length, comparable);
		}

		public static int BinarySearch<T, TComparable>(ref T spanStart, int length, TComparable comparable) where TComparable : IComparable<T>
		{
			int num = 0;
			int num2 = length - 1;
			while (num <= num2)
			{
				int num3 = num2 + num >>> 1;
				int num4 = comparable.CompareTo(Unsafe.Add(ref spanStart, num3));
				if (num4 == 0)
				{
					return num3;
				}
				if (num4 > 0)
				{
					num = num3 + 1;
				}
				else
				{
					num2 = num3 - 1;
				}
			}
			return ~num;
		}

		public static int IndexOf(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
		{
			if (valueLength == 0)
			{
				return 0;
			}
			byte value2 = value;
			ref byte second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = 0;
			while (true)
			{
				int num3 = searchSpaceLength - num2 - num;
				if (num3 <= 0)
				{
					break;
				}
				int num4 = IndexOf(ref Unsafe.Add(ref searchSpace, num2), value2, num3);
				if (num4 == -1)
				{
					break;
				}
				num2 += num4;
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num2 + 1), ref second, num))
				{
					return num2;
				}
				num2++;
			}
			return -1;
		}

		public static int IndexOfAny(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
		{
			if (valueLength == 0)
			{
				return 0;
			}
			int num = -1;
			for (int i = 0; i < valueLength; i++)
			{
				int num2 = IndexOf(ref searchSpace, Unsafe.Add(ref value, i), searchSpaceLength);
				if ((uint)num2 < (uint)num)
				{
					num = num2;
					searchSpaceLength = num2;
					if (num == 0)
					{
						break;
					}
				}
			}
			return num;
		}

		public static int LastIndexOfAny(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
		{
			if (valueLength == 0)
			{
				return 0;
			}
			int num = -1;
			for (int i = 0; i < valueLength; i++)
			{
				int num2 = LastIndexOf(ref searchSpace, Unsafe.Add(ref value, i), searchSpaceLength);
				if (num2 > num)
				{
					num = num2;
				}
			}
			return num;
		}

		public unsafe static int IndexOf(ref byte searchSpace, byte value, int length)
		{
			IntPtr intPtr = (IntPtr)0;
			IntPtr intPtr2 = (IntPtr)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				int num = (int)Unsafe.AsPointer(ref searchSpace) & (Vector<byte>.Count - 1);
				intPtr2 = (IntPtr)((Vector<byte>.Count - num) & (Vector<byte>.Count - 1));
			}
			while (true)
			{
				if ((nuint)(void*)intPtr2 >= (nuint)8u)
				{
					intPtr2 -= 8;
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr))
					{
						goto IL_0242;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 1))
					{
						goto IL_024a;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 2))
					{
						goto IL_0258;
					}
					if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 3))
					{
						if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 4))
						{
							if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 5))
							{
								if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 6))
								{
									if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 7))
									{
										break;
									}
									intPtr += 8;
									continue;
								}
								return (int)(void*)(intPtr + 6);
							}
							return (int)(void*)(intPtr + 5);
						}
						return (int)(void*)(intPtr + 4);
					}
					goto IL_0266;
				}
				if ((nuint)(void*)intPtr2 >= (nuint)4u)
				{
					intPtr2 -= 4;
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr))
					{
						goto IL_0242;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 1))
					{
						goto IL_024a;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 2))
					{
						goto IL_0258;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 3))
					{
						goto IL_0266;
					}
					intPtr += 4;
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr))
					{
						intPtr += 1;
						continue;
					}
					goto IL_0242;
				}
				if (Vector.IsHardwareAccelerated && (int)(void*)intPtr < length)
				{
					intPtr2 = (IntPtr)((length - (int)(void*)intPtr) & ~(Vector<byte>.Count - 1));
					Vector<byte> vector = GetVector(value);
					for (; (void*)intPtr2 > (void*)intPtr; intPtr += Vector<byte>.Count)
					{
						Vector<byte> vector2 = Vector.Equals(vector, Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref searchSpace, intPtr)));
						if (!Vector<byte>.Zero.Equals(vector2))
						{
							return (int)(void*)intPtr + LocateFirstFoundByte(vector2);
						}
					}
					if ((int)(void*)intPtr < length)
					{
						intPtr2 = (IntPtr)(length - (int)(void*)intPtr);
						continue;
					}
				}
				return -1;
				IL_0266:
				return (int)(void*)(intPtr + 3);
				IL_0242:
				return (int)(void*)intPtr;
				IL_0258:
				return (int)(void*)(intPtr + 2);
				IL_024a:
				return (int)(void*)(intPtr + 1);
			}
			return (int)(void*)(intPtr + 7);
		}

		public static int LastIndexOf(ref byte searchSpace, int searchSpaceLength, ref byte value, int valueLength)
		{
			if (valueLength == 0)
			{
				return 0;
			}
			byte value2 = value;
			ref byte second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = 0;
			while (true)
			{
				int num3 = searchSpaceLength - num2 - num;
				if (num3 <= 0)
				{
					break;
				}
				int num4 = LastIndexOf(ref searchSpace, value2, num3);
				if (num4 == -1)
				{
					break;
				}
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num4 + 1), ref second, num))
				{
					return num4;
				}
				num2 += num3 - num4;
			}
			return -1;
		}

		public unsafe static int LastIndexOf(ref byte searchSpace, byte value, int length)
		{
			IntPtr intPtr = (IntPtr)length;
			IntPtr intPtr2 = (IntPtr)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				int num = (int)Unsafe.AsPointer(ref searchSpace) & (Vector<byte>.Count - 1);
				intPtr2 = (IntPtr)(((length & (Vector<byte>.Count - 1)) + num) & (Vector<byte>.Count - 1));
			}
			while (true)
			{
				if ((nuint)(void*)intPtr2 >= (nuint)8u)
				{
					intPtr2 -= 8;
					intPtr -= 8;
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 7))
					{
						break;
					}
					if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 6))
					{
						if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 5))
						{
							if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 4))
							{
								if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 3))
								{
									if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 2))
									{
										if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr + 1))
										{
											if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr))
											{
												continue;
											}
											goto IL_0254;
										}
										goto IL_025c;
									}
									goto IL_026a;
								}
								goto IL_0278;
							}
							return (int)(void*)(intPtr + 4);
						}
						return (int)(void*)(intPtr + 5);
					}
					return (int)(void*)(intPtr + 6);
				}
				if ((nuint)(void*)intPtr2 >= (nuint)4u)
				{
					intPtr2 -= 4;
					intPtr -= 4;
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 3))
					{
						goto IL_0278;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 2))
					{
						goto IL_026a;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr + 1))
					{
						goto IL_025c;
					}
					if (value == Unsafe.AddByteOffset(ref searchSpace, intPtr))
					{
						goto IL_0254;
					}
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					intPtr -= 1;
					if (value != Unsafe.AddByteOffset(ref searchSpace, intPtr))
					{
						continue;
					}
					goto IL_0254;
				}
				if (Vector.IsHardwareAccelerated && (void*)intPtr != null)
				{
					intPtr2 = (IntPtr)((int)(void*)intPtr & ~(Vector<byte>.Count - 1));
					Vector<byte> vector = GetVector(value);
					for (; (nuint)(void*)intPtr2 > (nuint)(Vector<byte>.Count - 1); intPtr2 -= Vector<byte>.Count)
					{
						Vector<byte> vector2 = Vector.Equals(vector, Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref searchSpace, intPtr - Vector<byte>.Count)));
						if (Vector<byte>.Zero.Equals(vector2))
						{
							intPtr -= Vector<byte>.Count;
							continue;
						}
						return (int)intPtr - Vector<byte>.Count + LocateLastFoundByte(vector2);
					}
					if ((void*)intPtr != null)
					{
						intPtr2 = intPtr;
						continue;
					}
				}
				return -1;
				IL_0254:
				return (int)(void*)intPtr;
				IL_026a:
				return (int)(void*)(intPtr + 2);
				IL_0278:
				return (int)(void*)(intPtr + 3);
				IL_025c:
				return (int)(void*)(intPtr + 1);
			}
			return (int)(void*)(intPtr + 7);
		}

		public unsafe static int IndexOfAny(ref byte searchSpace, byte value0, byte value1, int length)
		{
			IntPtr intPtr = (IntPtr)0;
			IntPtr intPtr2 = (IntPtr)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				int num = (int)Unsafe.AsPointer(ref searchSpace) & (Vector<byte>.Count - 1);
				intPtr2 = (IntPtr)((Vector<byte>.Count - num) & (Vector<byte>.Count - 1));
			}
			while (true)
			{
				if ((nuint)(void*)intPtr2 >= (nuint)8u)
				{
					intPtr2 -= 8;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_02ff;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0307;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0315;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
					if (value0 != num2 && value1 != num2)
					{
						num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 4);
						if (value0 != num2 && value1 != num2)
						{
							num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 5);
							if (value0 != num2 && value1 != num2)
							{
								num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 6);
								if (value0 != num2 && value1 != num2)
								{
									num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 7);
									if (value0 == num2 || value1 == num2)
									{
										break;
									}
									intPtr += 8;
									continue;
								}
								return (int)(void*)(intPtr + 6);
							}
							return (int)(void*)(intPtr + 5);
						}
						return (int)(void*)(intPtr + 4);
					}
					goto IL_0323;
				}
				if ((nuint)(void*)intPtr2 >= (nuint)4u)
				{
					intPtr2 -= 4;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_02ff;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0307;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0315;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0323;
					}
					intPtr += 4;
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 != num2 && value1 != num2)
					{
						intPtr += 1;
						continue;
					}
					goto IL_02ff;
				}
				if (Vector.IsHardwareAccelerated && (int)(void*)intPtr < length)
				{
					intPtr2 = (IntPtr)((length - (int)(void*)intPtr) & ~(Vector<byte>.Count - 1));
					Vector<byte> vector = GetVector(value0);
					Vector<byte> vector2 = GetVector(value1);
					for (; (void*)intPtr2 > (void*)intPtr; intPtr += Vector<byte>.Count)
					{
						Vector<byte> left = Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref searchSpace, intPtr));
						Vector<byte> vector3 = Vector.BitwiseOr(Vector.Equals(left, vector), Vector.Equals(left, vector2));
						if (!Vector<byte>.Zero.Equals(vector3))
						{
							return (int)(void*)intPtr + LocateFirstFoundByte(vector3);
						}
					}
					if ((int)(void*)intPtr < length)
					{
						intPtr2 = (IntPtr)(length - (int)(void*)intPtr);
						continue;
					}
				}
				return -1;
				IL_02ff:
				return (int)(void*)intPtr;
				IL_0315:
				return (int)(void*)(intPtr + 2);
				IL_0307:
				return (int)(void*)(intPtr + 1);
				IL_0323:
				return (int)(void*)(intPtr + 3);
			}
			return (int)(void*)(intPtr + 7);
		}

		public unsafe static int IndexOfAny(ref byte searchSpace, byte value0, byte value1, byte value2, int length)
		{
			IntPtr intPtr = (IntPtr)0;
			IntPtr intPtr2 = (IntPtr)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				int num = (int)Unsafe.AsPointer(ref searchSpace) & (Vector<byte>.Count - 1);
				intPtr2 = (IntPtr)((Vector<byte>.Count - num) & (Vector<byte>.Count - 1));
			}
			while (true)
			{
				if ((nuint)(void*)intPtr2 >= (nuint)8u)
				{
					intPtr2 -= 8;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_0393;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_039b;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03a9;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
					if (value0 != num2 && value1 != num2 && value2 != num2)
					{
						num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 4);
						if (value0 != num2 && value1 != num2 && value2 != num2)
						{
							num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 5);
							if (value0 != num2 && value1 != num2 && value2 != num2)
							{
								num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 6);
								if (value0 != num2 && value1 != num2 && value2 != num2)
								{
									num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 7);
									if (value0 == num2 || value1 == num2 || value2 == num2)
									{
										break;
									}
									intPtr += 8;
									continue;
								}
								return (int)(void*)(intPtr + 6);
							}
							return (int)(void*)(intPtr + 5);
						}
						return (int)(void*)(intPtr + 4);
					}
					goto IL_03b7;
				}
				if ((nuint)(void*)intPtr2 >= (nuint)4u)
				{
					intPtr2 -= 4;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_0393;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_039b;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03a9;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03b7;
					}
					intPtr += 4;
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 != num2 && value1 != num2 && value2 != num2)
					{
						intPtr += 1;
						continue;
					}
					goto IL_0393;
				}
				if (Vector.IsHardwareAccelerated && (int)(void*)intPtr < length)
				{
					intPtr2 = (IntPtr)((length - (int)(void*)intPtr) & ~(Vector<byte>.Count - 1));
					Vector<byte> vector = GetVector(value0);
					Vector<byte> vector2 = GetVector(value1);
					Vector<byte> vector3 = GetVector(value2);
					for (; (void*)intPtr2 > (void*)intPtr; intPtr += Vector<byte>.Count)
					{
						Vector<byte> left = Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref searchSpace, intPtr));
						Vector<byte> vector4 = Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(left, vector), Vector.Equals(left, vector2)), Vector.Equals(left, vector3));
						if (!Vector<byte>.Zero.Equals(vector4))
						{
							return (int)(void*)intPtr + LocateFirstFoundByte(vector4);
						}
					}
					if ((int)(void*)intPtr < length)
					{
						intPtr2 = (IntPtr)(length - (int)(void*)intPtr);
						continue;
					}
				}
				return -1;
				IL_0393:
				return (int)(void*)intPtr;
				IL_039b:
				return (int)(void*)(intPtr + 1);
				IL_03b7:
				return (int)(void*)(intPtr + 3);
				IL_03a9:
				return (int)(void*)(intPtr + 2);
			}
			return (int)(void*)(intPtr + 7);
		}

		public unsafe static int LastIndexOfAny(ref byte searchSpace, byte value0, byte value1, int length)
		{
			IntPtr intPtr = (IntPtr)length;
			IntPtr intPtr2 = (IntPtr)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				int num = (int)Unsafe.AsPointer(ref searchSpace) & (Vector<byte>.Count - 1);
				intPtr2 = (IntPtr)(((length & (Vector<byte>.Count - 1)) + num) & (Vector<byte>.Count - 1));
			}
			while (true)
			{
				if ((nuint)(void*)intPtr2 >= (nuint)8u)
				{
					intPtr2 -= 8;
					intPtr -= 8;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 7);
					if (value0 == num2 || value1 == num2)
					{
						break;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 6);
					if (value0 != num2 && value1 != num2)
					{
						num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 5);
						if (value0 != num2 && value1 != num2)
						{
							num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 4);
							if (value0 != num2 && value1 != num2)
							{
								num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
								if (value0 != num2 && value1 != num2)
								{
									num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
									if (value0 != num2 && value1 != num2)
									{
										num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
										if (value0 != num2 && value1 != num2)
										{
											num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
											if (value0 != num2 && value1 != num2)
											{
												continue;
											}
											goto IL_0314;
										}
										goto IL_031c;
									}
									goto IL_032a;
								}
								goto IL_0338;
							}
							return (int)(void*)(intPtr + 4);
						}
						return (int)(void*)(intPtr + 5);
					}
					return (int)(void*)(intPtr + 6);
				}
				if ((nuint)(void*)intPtr2 >= (nuint)4u)
				{
					intPtr2 -= 4;
					intPtr -= 4;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0338;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_032a;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_031c;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2)
					{
						goto IL_0314;
					}
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					intPtr -= 1;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 != num2 && value1 != num2)
					{
						continue;
					}
					goto IL_0314;
				}
				if (Vector.IsHardwareAccelerated && (void*)intPtr != null)
				{
					intPtr2 = (IntPtr)((int)(void*)intPtr & ~(Vector<byte>.Count - 1));
					Vector<byte> vector = GetVector(value0);
					Vector<byte> vector2 = GetVector(value1);
					for (; (nuint)(void*)intPtr2 > (nuint)(Vector<byte>.Count - 1); intPtr2 -= Vector<byte>.Count)
					{
						Vector<byte> left = Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref searchSpace, intPtr - Vector<byte>.Count));
						Vector<byte> vector3 = Vector.BitwiseOr(Vector.Equals(left, vector), Vector.Equals(left, vector2));
						if (Vector<byte>.Zero.Equals(vector3))
						{
							intPtr -= Vector<byte>.Count;
							continue;
						}
						return (int)intPtr - Vector<byte>.Count + LocateLastFoundByte(vector3);
					}
					if ((void*)intPtr != null)
					{
						intPtr2 = intPtr;
						continue;
					}
				}
				return -1;
				IL_0314:
				return (int)(void*)intPtr;
				IL_0338:
				return (int)(void*)(intPtr + 3);
				IL_031c:
				return (int)(void*)(intPtr + 1);
				IL_032a:
				return (int)(void*)(intPtr + 2);
			}
			return (int)(void*)(intPtr + 7);
		}

		public unsafe static int LastIndexOfAny(ref byte searchSpace, byte value0, byte value1, byte value2, int length)
		{
			IntPtr intPtr = (IntPtr)length;
			IntPtr intPtr2 = (IntPtr)length;
			if (Vector.IsHardwareAccelerated && length >= Vector<byte>.Count * 2)
			{
				int num = (int)Unsafe.AsPointer(ref searchSpace) & (Vector<byte>.Count - 1);
				intPtr2 = (IntPtr)(((length & (Vector<byte>.Count - 1)) + num) & (Vector<byte>.Count - 1));
			}
			while (true)
			{
				if ((nuint)(void*)intPtr2 >= (nuint)8u)
				{
					intPtr2 -= 8;
					intPtr -= 8;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 7);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						break;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 6);
					if (value0 != num2 && value1 != num2 && value2 != num2)
					{
						num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 5);
						if (value0 != num2 && value1 != num2 && value2 != num2)
						{
							num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 4);
							if (value0 != num2 && value1 != num2 && value2 != num2)
							{
								num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
								if (value0 != num2 && value1 != num2 && value2 != num2)
								{
									num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
									if (value0 != num2 && value1 != num2 && value2 != num2)
									{
										num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
										if (value0 != num2 && value1 != num2 && value2 != num2)
										{
											num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
											if (value0 != num2 && value1 != num2 && value2 != num2)
											{
												continue;
											}
											goto IL_03ab;
										}
										goto IL_03b3;
									}
									goto IL_03c1;
								}
								goto IL_03cf;
							}
							return (int)(void*)(intPtr + 4);
						}
						return (int)(void*)(intPtr + 5);
					}
					return (int)(void*)(intPtr + 6);
				}
				if ((nuint)(void*)intPtr2 >= (nuint)4u)
				{
					intPtr2 -= 4;
					intPtr -= 4;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 3);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03cf;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 2);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03c1;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr + 1);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03b3;
					}
					num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 == num2 || value1 == num2 || value2 == num2)
					{
						goto IL_03ab;
					}
				}
				while ((void*)intPtr2 != null)
				{
					intPtr2 -= 1;
					intPtr -= 1;
					uint num2 = Unsafe.AddByteOffset(ref searchSpace, intPtr);
					if (value0 != num2 && value1 != num2 && value2 != num2)
					{
						continue;
					}
					goto IL_03ab;
				}
				if (Vector.IsHardwareAccelerated && (void*)intPtr != null)
				{
					intPtr2 = (IntPtr)((int)(void*)intPtr & ~(Vector<byte>.Count - 1));
					Vector<byte> vector = GetVector(value0);
					Vector<byte> vector2 = GetVector(value1);
					Vector<byte> vector3 = GetVector(value2);
					for (; (nuint)(void*)intPtr2 > (nuint)(Vector<byte>.Count - 1); intPtr2 -= Vector<byte>.Count)
					{
						Vector<byte> left = Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref searchSpace, intPtr - Vector<byte>.Count));
						Vector<byte> vector4 = Vector.BitwiseOr(Vector.BitwiseOr(Vector.Equals(left, vector), Vector.Equals(left, vector2)), Vector.Equals(left, vector3));
						if (Vector<byte>.Zero.Equals(vector4))
						{
							intPtr -= Vector<byte>.Count;
							continue;
						}
						return (int)intPtr - Vector<byte>.Count + LocateLastFoundByte(vector4);
					}
					if ((void*)intPtr != null)
					{
						intPtr2 = intPtr;
						continue;
					}
				}
				return -1;
				IL_03ab:
				return (int)(void*)intPtr;
				IL_03cf:
				return (int)(void*)(intPtr + 3);
				IL_03c1:
				return (int)(void*)(intPtr + 2);
				IL_03b3:
				return (int)(void*)(intPtr + 1);
			}
			return (int)(void*)(intPtr + 7);
		}

		public unsafe static bool SequenceEqual(ref byte first, ref byte second, NUInt length)
		{
			if (Unsafe.AreSame(ref first, ref second))
			{
				goto IL_013d;
			}
			IntPtr intPtr = (IntPtr)0;
			IntPtr intPtr2 = (IntPtr)(void*)length;
			if (Vector.IsHardwareAccelerated && (nuint)(void*)intPtr2 >= (nuint)Vector<byte>.Count)
			{
				intPtr2 -= Vector<byte>.Count;
				while (true)
				{
					if ((void*)intPtr2 > (void*)intPtr)
					{
						if (Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref first, intPtr)) != Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref second, intPtr)))
						{
							break;
						}
						intPtr += Vector<byte>.Count;
						continue;
					}
					return Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref first, intPtr2)) == Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref second, intPtr2));
				}
			}
			else
			{
				if ((nuint)(void*)intPtr2 < (nuint)sizeof(UIntPtr))
				{
					while ((void*)intPtr2 > (void*)intPtr)
					{
						if (Unsafe.AddByteOffset(ref first, intPtr) == Unsafe.AddByteOffset(ref second, intPtr))
						{
							intPtr += 1;
							continue;
						}
						goto IL_013f;
					}
					goto IL_013d;
				}
				intPtr2 -= sizeof(UIntPtr);
				while (true)
				{
					if ((void*)intPtr2 > (void*)intPtr)
					{
						if (Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.AddByteOffset(ref first, intPtr)) != Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.AddByteOffset(ref second, intPtr)))
						{
							break;
						}
						intPtr += sizeof(UIntPtr);
						continue;
					}
					return Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.AddByteOffset(ref first, intPtr2)) == Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.AddByteOffset(ref second, intPtr2));
				}
			}
			goto IL_013f;
			IL_013d:
			return true;
			IL_013f:
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundByte(Vector<byte> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int i;
			for (i = 0; i < Vector<ulong>.Count; i++)
			{
				num = vector[i];
				if (num != 0L)
				{
					break;
				}
			}
			return i * 8 + LocateFirstFoundByte(num);
		}

		public unsafe static int SequenceCompareTo(ref byte first, int firstLength, ref byte second, int secondLength)
		{
			if (!Unsafe.AreSame(ref first, ref second))
			{
				IntPtr intPtr = (IntPtr)((firstLength < secondLength) ? firstLength : secondLength);
				IntPtr intPtr2 = (IntPtr)0;
				IntPtr intPtr3 = (IntPtr)(void*)intPtr;
				if (Vector.IsHardwareAccelerated && (nuint)(void*)intPtr3 > (nuint)Vector<byte>.Count)
				{
					intPtr3 -= Vector<byte>.Count;
					for (; (void*)intPtr3 > (void*)intPtr2 && !(Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref first, intPtr2)) != Unsafe.ReadUnaligned<Vector<byte>>(ref Unsafe.AddByteOffset(ref second, intPtr2))); intPtr2 += Vector<byte>.Count)
					{
					}
				}
				else if ((nuint)(void*)intPtr3 > (nuint)sizeof(UIntPtr))
				{
					intPtr3 -= sizeof(UIntPtr);
					for (; (void*)intPtr3 > (void*)intPtr2 && !(Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.AddByteOffset(ref first, intPtr2)) != Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.AddByteOffset(ref second, intPtr2))); intPtr2 += sizeof(UIntPtr))
					{
					}
				}
				for (; (void*)intPtr > (void*)intPtr2; intPtr2 += 1)
				{
					int num = Unsafe.AddByteOffset(ref first, intPtr2).CompareTo(Unsafe.AddByteOffset(ref second, intPtr2));
					if (num != 0)
					{
						return num;
					}
				}
			}
			return firstLength - secondLength;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundByte(Vector<byte> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int num2;
			for (num2 = Vector<ulong>.Count - 1; num2 >= 0; num2--)
			{
				num = vector[num2];
				if (num != 0L)
				{
					break;
				}
			}
			return num2 * 8 + LocateLastFoundByte(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundByte(ulong match)
		{
			ulong num = match ^ (match - 1);
			return (int)(num * 283686952306184L >> 57);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundByte(ulong match)
		{
			int num = 7;
			while ((long)match > 0L)
			{
				match <<= 8;
				num--;
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static Vector<byte> GetVector(byte vectorByte)
		{
			return Vector.AsVectorByte(new Vector<uint>((uint)(vectorByte * 16843009)));
		}

		public unsafe static int SequenceCompareTo(ref char first, int firstLength, ref char second, int secondLength)
		{
			int result = firstLength - secondLength;
			if (!Unsafe.AreSame(ref first, ref second))
			{
				IntPtr intPtr = (IntPtr)((firstLength < secondLength) ? firstLength : secondLength);
				IntPtr intPtr2 = (IntPtr)0;
				if ((nuint)(void*)intPtr >= (nuint)(sizeof(UIntPtr) / 2))
				{
					if (Vector.IsHardwareAccelerated && (nuint)(void*)intPtr >= (nuint)Vector<ushort>.Count)
					{
						IntPtr intPtr3 = intPtr - Vector<ushort>.Count;
						while (!(Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, intPtr2))) != Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, intPtr2)))))
						{
							intPtr2 += Vector<ushort>.Count;
							if ((void*)intPtr3 < (void*)intPtr2)
							{
								break;
							}
						}
					}
					for (; (void*)intPtr >= (void*)(intPtr2 + sizeof(UIntPtr) / 2) && !(Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, intPtr2))) != Unsafe.ReadUnaligned<UIntPtr>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, intPtr2)))); intPtr2 += sizeof(UIntPtr) / 2)
					{
					}
				}
				if (sizeof(UIntPtr) > 4 && (void*)intPtr >= (void*)(intPtr2 + 2) && Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, intPtr2))) == Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, intPtr2))))
				{
					intPtr2 += 2;
				}
				for (; (void*)intPtr2 < (void*)intPtr; intPtr2 += 1)
				{
					int num = Unsafe.Add(ref first, intPtr2).CompareTo(Unsafe.Add(ref second, intPtr2));
					if (num != 0)
					{
						return num;
					}
				}
			}
			return result;
		}

		public unsafe static int IndexOf(ref char searchSpace, char value, int length)
		{
			fixed (char* ptr = &searchSpace)
			{
				char* ptr2 = ptr;
				char* ptr3 = ptr2 + length;
				if (Vector.IsHardwareAccelerated && length >= Vector<ushort>.Count * 2)
				{
					int num = ((int)ptr2 & (Unsafe.SizeOf<Vector<ushort>>() - 1)) / 2;
					length = (Vector<ushort>.Count - num) & (Vector<ushort>.Count - 1);
				}
				while (true)
				{
					if (length >= 4)
					{
						length -= 4;
						if (*ptr2 == value)
						{
							break;
						}
						if (ptr2[1] != value)
						{
							if (ptr2[2] != value)
							{
								if (ptr2[3] != value)
								{
									ptr2 += 4;
									continue;
								}
								ptr2++;
							}
							ptr2++;
						}
						ptr2++;
						break;
					}
					while (length > 0)
					{
						length--;
						if (*ptr2 == value)
						{
							goto end_IL_0079;
						}
						ptr2++;
					}
					if (Vector.IsHardwareAccelerated && ptr2 < ptr3)
					{
						length = (int)((ptr3 - ptr2) & ~(Vector<ushort>.Count - 1));
						Vector<ushort> left = new Vector<ushort>(value);
						while (length > 0)
						{
							Vector<ushort> vector = Vector.Equals(left, Unsafe.Read<Vector<ushort>>(ptr2));
							if (Vector<ushort>.Zero.Equals(vector))
							{
								ptr2 += Vector<ushort>.Count;
								length -= Vector<ushort>.Count;
								continue;
							}
							return (int)(ptr2 - ptr) + LocateFirstFoundChar(vector);
						}
						if (ptr2 < ptr3)
						{
							length = (int)(ptr3 - ptr2);
							continue;
						}
					}
					return -1;
					continue;
					end_IL_0079:
					break;
				}
				return (int)(ptr2 - ptr);
			}
		}

		public unsafe static int LastIndexOf(ref char searchSpace, char value, int length)
		{
			fixed (char* ptr = &searchSpace)
			{
				char* ptr2 = ptr + length;
				char* ptr3 = ptr;
				if (Vector.IsHardwareAccelerated && length >= Vector<ushort>.Count * 2)
				{
					length = ((int)ptr2 & (Unsafe.SizeOf<Vector<ushort>>() - 1)) / 2;
				}
				while (true)
				{
					if (length >= 4)
					{
						length -= 4;
						ptr2 -= 4;
						if (ptr2[3] == value)
						{
							break;
						}
						if (ptr2[2] != value)
						{
							if (ptr2[1] != value)
							{
								if (*ptr2 != value)
								{
									continue;
								}
								goto IL_011d;
							}
							return (int)(ptr2 - ptr3) + 1;
						}
						return (int)(ptr2 - ptr3) + 2;
					}
					while (length > 0)
					{
						length--;
						ptr2--;
						if (*ptr2 != value)
						{
							continue;
						}
						goto IL_011d;
					}
					if (Vector.IsHardwareAccelerated && ptr2 > ptr3)
					{
						length = (int)((ptr2 - ptr3) & ~(Vector<ushort>.Count - 1));
						Vector<ushort> left = new Vector<ushort>(value);
						while (length > 0)
						{
							char* ptr4 = ptr2 - Vector<ushort>.Count;
							Vector<ushort> vector = Vector.Equals(left, Unsafe.Read<Vector<ushort>>(ptr4));
							if (Vector<ushort>.Zero.Equals(vector))
							{
								ptr2 -= Vector<ushort>.Count;
								length -= Vector<ushort>.Count;
								continue;
							}
							return (int)(ptr4 - ptr3) + LocateLastFoundChar(vector);
						}
						if (ptr2 > ptr3)
						{
							length = (int)(ptr2 - ptr3);
							continue;
						}
					}
					return -1;
					IL_011d:
					return (int)(ptr2 - ptr3);
				}
				return (int)(ptr2 - ptr3) + 3;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundChar(Vector<ushort> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int i;
			for (i = 0; i < Vector<ulong>.Count; i++)
			{
				num = vector[i];
				if (num != 0L)
				{
					break;
				}
			}
			return i * 4 + LocateFirstFoundChar(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateFirstFoundChar(ulong match)
		{
			ulong num = match ^ (match - 1);
			return (int)(num * 4295098372L >> 49);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundChar(Vector<ushort> match)
		{
			Vector<ulong> vector = Vector.AsVectorUInt64(match);
			ulong num = 0uL;
			int num2;
			for (num2 = Vector<ulong>.Count - 1; num2 >= 0; num2--)
			{
				num = vector[num2];
				if (num != 0L)
				{
					break;
				}
			}
			return num2 * 4 + LocateLastFoundChar(num);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int LocateLastFoundChar(ulong match)
		{
			int num = 3;
			while ((long)match > 0L)
			{
				match <<= 16;
				num--;
			}
			return num;
		}

		public static int IndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return 0;
			}
			T value2 = value;
			ref T second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = 0;
			while (true)
			{
				int num3 = searchSpaceLength - num2 - num;
				if (num3 <= 0)
				{
					break;
				}
				int num4 = IndexOf(ref Unsafe.Add(ref searchSpace, num2), value2, num3);
				if (num4 == -1)
				{
					break;
				}
				num2 += num4;
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num2 + 1), ref second, num))
				{
					return num2;
				}
				num2++;
			}
			return -1;
		}

		public unsafe static int IndexOf<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
		{
			IntPtr intPtr = (IntPtr)0;
			while (true)
			{
				if (length >= 8)
				{
					length -= 8;
					if (!value.Equals(Unsafe.Add(ref searchSpace, intPtr)))
					{
						if (value.Equals(Unsafe.Add(ref searchSpace, intPtr + 1)))
						{
							goto IL_020a;
						}
						if (value.Equals(Unsafe.Add(ref searchSpace, intPtr + 2)))
						{
							goto IL_0218;
						}
						if (!value.Equals(Unsafe.Add(ref searchSpace, intPtr + 3)))
						{
							if (!value.Equals(Unsafe.Add(ref searchSpace, intPtr + 4)))
							{
								if (!value.Equals(Unsafe.Add(ref searchSpace, intPtr + 5)))
								{
									if (!value.Equals(Unsafe.Add(ref searchSpace, intPtr + 6)))
									{
										if (value.Equals(Unsafe.Add(ref searchSpace, intPtr + 7)))
										{
											break;
										}
										intPtr += 8;
										continue;
									}
									return (int)(void*)(intPtr + 6);
								}
								return (int)(void*)(intPtr + 5);
							}
							return (int)(void*)(intPtr + 4);
						}
						goto IL_0226;
					}
				}
				else
				{
					if (length >= 4)
					{
						length -= 4;
						if (value.Equals(Unsafe.Add(ref searchSpace, intPtr)))
						{
							goto IL_0202;
						}
						if (value.Equals(Unsafe.Add(ref searchSpace, intPtr + 1)))
						{
							goto IL_020a;
						}
						if (value.Equals(Unsafe.Add(ref searchSpace, intPtr + 2)))
						{
							goto IL_0218;
						}
						if (value.Equals(Unsafe.Add(ref searchSpace, intPtr + 3)))
						{
							goto IL_0226;
						}
						intPtr += 4;
					}
					while (true)
					{
						if (length > 0)
						{
							if (value.Equals(Unsafe.Add(ref searchSpace, intPtr)))
							{
								break;
							}
							intPtr += 1;
							length--;
							continue;
						}
						return -1;
					}
				}
				goto IL_0202;
				IL_0218:
				return (int)(void*)(intPtr + 2);
				IL_0202:
				return (int)(void*)intPtr;
				IL_020a:
				return (int)(void*)(intPtr + 1);
				IL_0226:
				return (int)(void*)(intPtr + 3);
			}
			return (int)(void*)(intPtr + 7);
		}

		public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, int length) where T : IEquatable<T>
		{
			int num = 0;
			while (true)
			{
				if (length - num >= 8)
				{
					T other = Unsafe.Add(ref searchSpace, num);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						other = Unsafe.Add(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cb;
						}
						other = Unsafe.Add(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cf;
						}
						other = Unsafe.Add(ref searchSpace, num + 3);
						if (!value0.Equals(other) && !value1.Equals(other))
						{
							other = Unsafe.Add(ref searchSpace, num + 4);
							if (!value0.Equals(other) && !value1.Equals(other))
							{
								other = Unsafe.Add(ref searchSpace, num + 5);
								if (!value0.Equals(other) && !value1.Equals(other))
								{
									other = Unsafe.Add(ref searchSpace, num + 6);
									if (!value0.Equals(other) && !value1.Equals(other))
									{
										other = Unsafe.Add(ref searchSpace, num + 7);
										if (value0.Equals(other) || value1.Equals(other))
										{
											break;
										}
										num += 8;
										continue;
									}
									return num + 6;
								}
								return num + 5;
							}
							return num + 4;
						}
						goto IL_02d3;
					}
				}
				else
				{
					if (length - num >= 4)
					{
						T other = Unsafe.Add(ref searchSpace, num);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c9;
						}
						other = Unsafe.Add(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cb;
						}
						other = Unsafe.Add(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cf;
						}
						other = Unsafe.Add(ref searchSpace, num + 3);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02d3;
						}
						num += 4;
					}
					while (true)
					{
						if (num < length)
						{
							T other = Unsafe.Add(ref searchSpace, num);
							if (value0.Equals(other) || value1.Equals(other))
							{
								break;
							}
							num++;
							continue;
						}
						return -1;
					}
				}
				goto IL_02c9;
				IL_02cf:
				return num + 2;
				IL_02cb:
				return num + 1;
				IL_02d3:
				return num + 3;
				IL_02c9:
				return num;
			}
			return num + 7;
		}

		public static int IndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length) where T : IEquatable<T>
		{
			int num = 0;
			while (true)
			{
				if (length - num >= 8)
				{
					T other = Unsafe.Add(ref searchSpace, num);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						other = Unsafe.Add(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c2;
						}
						other = Unsafe.Add(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c6;
						}
						other = Unsafe.Add(ref searchSpace, num + 3);
						if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
						{
							other = Unsafe.Add(ref searchSpace, num + 4);
							if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
							{
								other = Unsafe.Add(ref searchSpace, num + 5);
								if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
								{
									other = Unsafe.Add(ref searchSpace, num + 6);
									if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
									{
										other = Unsafe.Add(ref searchSpace, num + 7);
										if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
										{
											break;
										}
										num += 8;
										continue;
									}
									return num + 6;
								}
								return num + 5;
							}
							return num + 4;
						}
						goto IL_03ca;
					}
				}
				else
				{
					if (length - num >= 4)
					{
						T other = Unsafe.Add(ref searchSpace, num);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c0;
						}
						other = Unsafe.Add(ref searchSpace, num + 1);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c2;
						}
						other = Unsafe.Add(ref searchSpace, num + 2);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03c6;
						}
						other = Unsafe.Add(ref searchSpace, num + 3);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03ca;
						}
						num += 4;
					}
					while (true)
					{
						if (num < length)
						{
							T other = Unsafe.Add(ref searchSpace, num);
							if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
							{
								break;
							}
							num++;
							continue;
						}
						return -1;
					}
				}
				goto IL_03c0;
				IL_03c0:
				return num;
				IL_03c6:
				return num + 2;
				IL_03c2:
				return num + 1;
				IL_03ca:
				return num + 3;
			}
			return num + 7;
		}

		public static int IndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return 0;
			}
			int num = -1;
			for (int i = 0; i < valueLength; i++)
			{
				int num2 = IndexOf(ref searchSpace, Unsafe.Add(ref value, i), searchSpaceLength);
				if ((uint)num2 < (uint)num)
				{
					num = num2;
					searchSpaceLength = num2;
					if (num == 0)
					{
						break;
					}
				}
			}
			return num;
		}

		public static int LastIndexOf<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return 0;
			}
			T value2 = value;
			ref T second = ref Unsafe.Add(ref value, 1);
			int num = valueLength - 1;
			int num2 = 0;
			while (true)
			{
				int num3 = searchSpaceLength - num2 - num;
				if (num3 <= 0)
				{
					break;
				}
				int num4 = LastIndexOf(ref searchSpace, value2, num3);
				if (num4 == -1)
				{
					break;
				}
				if (SequenceEqual(ref Unsafe.Add(ref searchSpace, num4 + 1), ref second, num))
				{
					return num4;
				}
				num2 += num3 - num4;
			}
			return -1;
		}

		public static int LastIndexOf<T>(ref T searchSpace, T value, int length) where T : IEquatable<T>
		{
			while (true)
			{
				if (length >= 8)
				{
					length -= 8;
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 7)))
					{
						break;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 6)))
					{
						return length + 6;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 5)))
					{
						return length + 5;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 4)))
					{
						return length + 4;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
					{
						goto IL_01c2;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
					{
						goto IL_01be;
					}
					if (value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
					{
						goto IL_01ba;
					}
					if (!value.Equals(Unsafe.Add(ref searchSpace, length)))
					{
						continue;
					}
				}
				else
				{
					if (length >= 4)
					{
						length -= 4;
						if (value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
						{
							goto IL_01c2;
						}
						if (value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
						{
							goto IL_01be;
						}
						if (value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
						{
							goto IL_01ba;
						}
						if (value.Equals(Unsafe.Add(ref searchSpace, length)))
						{
							goto IL_01b8;
						}
					}
					do
					{
						if (length > 0)
						{
							length--;
							continue;
						}
						return -1;
					}
					while (!value.Equals(Unsafe.Add(ref searchSpace, length)));
				}
				goto IL_01b8;
				IL_01be:
				return length + 2;
				IL_01c2:
				return length + 3;
				IL_01ba:
				return length + 1;
				IL_01b8:
				return length;
			}
			return length + 7;
		}

		public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, int length) where T : IEquatable<T>
		{
			while (true)
			{
				if (length >= 8)
				{
					length -= 8;
					T other = Unsafe.Add(ref searchSpace, length + 7);
					if (value0.Equals(other) || value1.Equals(other))
					{
						break;
					}
					other = Unsafe.Add(ref searchSpace, length + 6);
					if (value0.Equals(other) || value1.Equals(other))
					{
						return length + 6;
					}
					other = Unsafe.Add(ref searchSpace, length + 5);
					if (value0.Equals(other) || value1.Equals(other))
					{
						return length + 5;
					}
					other = Unsafe.Add(ref searchSpace, length + 4);
					if (value0.Equals(other) || value1.Equals(other))
					{
						return length + 4;
					}
					other = Unsafe.Add(ref searchSpace, length + 3);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_02cd;
					}
					other = Unsafe.Add(ref searchSpace, length + 2);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_02c9;
					}
					other = Unsafe.Add(ref searchSpace, length + 1);
					if (value0.Equals(other) || value1.Equals(other))
					{
						goto IL_02c5;
					}
					other = Unsafe.Add(ref searchSpace, length);
					if (!value0.Equals(other) && !value1.Equals(other))
					{
						continue;
					}
				}
				else
				{
					T other;
					if (length >= 4)
					{
						length -= 4;
						other = Unsafe.Add(ref searchSpace, length + 3);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02cd;
						}
						other = Unsafe.Add(ref searchSpace, length + 2);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c9;
						}
						other = Unsafe.Add(ref searchSpace, length + 1);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c5;
						}
						other = Unsafe.Add(ref searchSpace, length);
						if (value0.Equals(other) || value1.Equals(other))
						{
							goto IL_02c3;
						}
					}
					do
					{
						if (length > 0)
						{
							length--;
							other = Unsafe.Add(ref searchSpace, length);
							continue;
						}
						return -1;
					}
					while (!value0.Equals(other) && !value1.Equals(other));
				}
				goto IL_02c3;
				IL_02c9:
				return length + 2;
				IL_02c5:
				return length + 1;
				IL_02c3:
				return length;
				IL_02cd:
				return length + 3;
			}
			return length + 7;
		}

		public static int LastIndexOfAny<T>(ref T searchSpace, T value0, T value1, T value2, int length) where T : IEquatable<T>
		{
			while (true)
			{
				if (length >= 8)
				{
					length -= 8;
					T other = Unsafe.Add(ref searchSpace, length + 7);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						break;
					}
					other = Unsafe.Add(ref searchSpace, length + 6);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						return length + 6;
					}
					other = Unsafe.Add(ref searchSpace, length + 5);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						return length + 5;
					}
					other = Unsafe.Add(ref searchSpace, length + 4);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						return length + 4;
					}
					other = Unsafe.Add(ref searchSpace, length + 3);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_03da;
					}
					other = Unsafe.Add(ref searchSpace, length + 2);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_03d5;
					}
					other = Unsafe.Add(ref searchSpace, length + 1);
					if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
					{
						goto IL_03d0;
					}
					other = Unsafe.Add(ref searchSpace, length);
					if (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other))
					{
						continue;
					}
				}
				else
				{
					T other;
					if (length >= 4)
					{
						length -= 4;
						other = Unsafe.Add(ref searchSpace, length + 3);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03da;
						}
						other = Unsafe.Add(ref searchSpace, length + 2);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03d5;
						}
						other = Unsafe.Add(ref searchSpace, length + 1);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03d0;
						}
						other = Unsafe.Add(ref searchSpace, length);
						if (value0.Equals(other) || value1.Equals(other) || value2.Equals(other))
						{
							goto IL_03cd;
						}
					}
					do
					{
						if (length > 0)
						{
							length--;
							other = Unsafe.Add(ref searchSpace, length);
							continue;
						}
						return -1;
					}
					while (!value0.Equals(other) && !value1.Equals(other) && !value2.Equals(other));
				}
				goto IL_03cd;
				IL_03d0:
				return length + 1;
				IL_03d5:
				return length + 2;
				IL_03da:
				return length + 3;
				IL_03cd:
				return length;
			}
			return length + 7;
		}

		public static int LastIndexOfAny<T>(ref T searchSpace, int searchSpaceLength, ref T value, int valueLength) where T : IEquatable<T>
		{
			if (valueLength == 0)
			{
				return 0;
			}
			int num = -1;
			for (int i = 0; i < valueLength; i++)
			{
				int num2 = LastIndexOf(ref searchSpace, Unsafe.Add(ref value, i), searchSpaceLength);
				if (num2 > num)
				{
					num = num2;
				}
			}
			return num;
		}

		public static bool SequenceEqual<T>(ref T first, ref T second, int length) where T : IEquatable<T>
		{
			if (!Unsafe.AreSame(ref first, ref second))
			{
				IntPtr intPtr = (IntPtr)0;
				while (true)
				{
					if (length >= 8)
					{
						length -= 8;
						if (Unsafe.Add(ref first, intPtr).Equals(Unsafe.Add(ref second, intPtr)) && Unsafe.Add(ref first, intPtr + 1).Equals(Unsafe.Add(ref second, intPtr + 1)) && Unsafe.Add(ref first, intPtr + 2).Equals(Unsafe.Add(ref second, intPtr + 2)) && Unsafe.Add(ref first, intPtr + 3).Equals(Unsafe.Add(ref second, intPtr + 3)) && Unsafe.Add(ref first, intPtr + 4).Equals(Unsafe.Add(ref second, intPtr + 4)) && Unsafe.Add(ref first, intPtr + 5).Equals(Unsafe.Add(ref second, intPtr + 5)) && Unsafe.Add(ref first, intPtr + 6).Equals(Unsafe.Add(ref second, intPtr + 6)) && Unsafe.Add(ref first, intPtr + 7).Equals(Unsafe.Add(ref second, intPtr + 7)))
						{
							intPtr += 8;
							continue;
						}
						goto IL_028b;
					}
					if (length >= 4)
					{
						length -= 4;
						if (!Unsafe.Add(ref first, intPtr).Equals(Unsafe.Add(ref second, intPtr)) || !Unsafe.Add(ref first, intPtr + 1).Equals(Unsafe.Add(ref second, intPtr + 1)) || !Unsafe.Add(ref first, intPtr + 2).Equals(Unsafe.Add(ref second, intPtr + 2)) || !Unsafe.Add(ref first, intPtr + 3).Equals(Unsafe.Add(ref second, intPtr + 3)))
						{
							goto IL_028b;
						}
						intPtr += 4;
					}
					while (length > 0)
					{
						if (Unsafe.Add(ref first, intPtr).Equals(Unsafe.Add(ref second, intPtr)))
						{
							intPtr += 1;
							length--;
							continue;
						}
						goto IL_028b;
					}
					break;
					IL_028b:
					return false;
				}
			}
			return true;
		}

		public static int SequenceCompareTo<T>(ref T first, int firstLength, ref T second, int secondLength) where T : IComparable<T>
		{
			int num = firstLength;
			if (num > secondLength)
			{
				num = secondLength;
			}
			for (int i = 0; i < num; i++)
			{
				int num2 = Unsafe.Add(ref first, i).CompareTo(Unsafe.Add(ref second, i));
				if (num2 != 0)
				{
					return num2;
				}
			}
			return firstLength.CompareTo(secondLength);
		}

		public unsafe static void CopyTo<T>(ref T dst, int dstLength, ref T src, int srcLength)
		{
			IntPtr intPtr = Unsafe.ByteOffset(ref src, ref Unsafe.Add(ref src, srcLength));
			IntPtr intPtr2 = Unsafe.ByteOffset(ref dst, ref Unsafe.Add(ref dst, dstLength));
			IntPtr intPtr3 = Unsafe.ByteOffset(ref src, ref dst);
			bool num;
			if (sizeof(IntPtr) != 4)
			{
				if ((ulong)(long)intPtr3 >= (ulong)(long)intPtr)
				{
					num = (ulong)(long)intPtr3 > (ulong)(-(long)intPtr2);
					goto IL_006f;
				}
			}
			else if ((uint)(int)intPtr3 >= (uint)(int)intPtr)
			{
				num = (uint)(int)intPtr3 > (uint)(-(int)intPtr2);
				goto IL_006f;
			}
			goto IL_00de;
			IL_00de:
			bool flag = ((sizeof(IntPtr) == 4) ? ((uint)(int)intPtr3 > (uint)(-(int)intPtr2)) : ((ulong)(long)intPtr3 > (ulong)(-(long)intPtr2)));
			int num2 = (flag ? 1 : (-1));
			int num3 = ((!flag) ? (srcLength - 1) : 0);
			int i;
			for (i = 0; i < (srcLength & -8); i += 8)
			{
				Unsafe.Add(ref dst, num3) = Unsafe.Add(ref src, num3);
				Unsafe.Add(ref dst, num3 + num2) = Unsafe.Add(ref src, num3 + num2);
				Unsafe.Add(ref dst, num3 + num2 * 2) = Unsafe.Add(ref src, num3 + num2 * 2);
				Unsafe.Add(ref dst, num3 + num2 * 3) = Unsafe.Add(ref src, num3 + num2 * 3);
				Unsafe.Add(ref dst, num3 + num2 * 4) = Unsafe.Add(ref src, num3 + num2 * 4);
				Unsafe.Add(ref dst, num3 + num2 * 5) = Unsafe.Add(ref src, num3 + num2 * 5);
				Unsafe.Add(ref dst, num3 + num2 * 6) = Unsafe.Add(ref src, num3 + num2 * 6);
				Unsafe.Add(ref dst, num3 + num2 * 7) = Unsafe.Add(ref src, num3 + num2 * 7);
				num3 += num2 * 8;
			}
			if (i < (srcLength & -4))
			{
				Unsafe.Add(ref dst, num3) = Unsafe.Add(ref src, num3);
				Unsafe.Add(ref dst, num3 + num2) = Unsafe.Add(ref src, num3 + num2);
				Unsafe.Add(ref dst, num3 + num2 * 2) = Unsafe.Add(ref src, num3 + num2 * 2);
				Unsafe.Add(ref dst, num3 + num2 * 3) = Unsafe.Add(ref src, num3 + num2 * 3);
				num3 += num2 * 4;
				i += 4;
			}
			for (; i < srcLength; i++)
			{
				Unsafe.Add(ref dst, num3) = Unsafe.Add(ref src, num3);
				num3 += num2;
			}
			return;
			IL_006f:
			if (!num && !IsReferenceOrContainsReferences<T>())
			{
				ref byte source = ref Unsafe.As<T, byte>(ref dst);
				ref byte source2 = ref Unsafe.As<T, byte>(ref src);
				ulong num4 = (ulong)(long)intPtr;
				uint num6;
				for (ulong num5 = 0uL; num5 < num4; num5 += num6)
				{
					num6 = (uint)((num4 - num5 > uint.MaxValue) ? uint.MaxValue : (num4 - num5));
					Unsafe.CopyBlock(ref Unsafe.Add(ref source, (IntPtr)(long)num5), ref Unsafe.Add(ref source2, (IntPtr)(long)num5), num6);
				}
				return;
			}
			goto IL_00de;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static IntPtr Add<T>(this IntPtr start, int index)
		{
			if (sizeof(IntPtr) == 4)
			{
				uint num = (uint)(index * Unsafe.SizeOf<T>());
				return (IntPtr)((byte*)(void*)start + num);
			}
			ulong num2 = (ulong)index * (ulong)Unsafe.SizeOf<T>();
			return (IntPtr)((byte*)(void*)start + num2);
		}

		public static bool IsReferenceOrContainsReferences<T>()
		{
			return PerTypeValues<T>.IsReferenceOrContainsReferences;
		}

		private static bool IsReferenceOrContainsReferencesCore(Type type)
		{
			if (type.GetTypeInfo().IsPrimitive)
			{
				return false;
			}
			if (!type.GetTypeInfo().IsValueType)
			{
				return true;
			}
			Type underlyingType = Nullable.GetUnderlyingType(type);
			if (underlyingType != null)
			{
				type = underlyingType;
			}
			if (type.GetTypeInfo().IsEnum)
			{
				return false;
			}
			foreach (FieldInfo declaredField in type.GetTypeInfo().DeclaredFields)
			{
				if (!declaredField.IsStatic && IsReferenceOrContainsReferencesCore(declaredField.FieldType))
				{
					return true;
				}
			}
			return false;
		}

		public unsafe static void ClearLessThanPointerSized(byte* ptr, UIntPtr byteLength)
		{
			if (sizeof(UIntPtr) == 4)
			{
				Unsafe.InitBlockUnaligned(ptr, 0, (uint)byteLength);
				return;
			}
			ulong num = (ulong)byteLength;
			uint num2 = (uint)(num & 0xFFFFFFFFu);
			Unsafe.InitBlockUnaligned(ptr, 0, num2);
			num -= num2;
			ptr += num2;
			while (num != 0)
			{
				num2 = (uint)((num >= uint.MaxValue) ? uint.MaxValue : num);
				Unsafe.InitBlockUnaligned(ptr, 0, num2);
				ptr += num2;
				num -= num2;
			}
		}

		public unsafe static void ClearLessThanPointerSized(ref byte b, UIntPtr byteLength)
		{
			if (sizeof(UIntPtr) == 4)
			{
				Unsafe.InitBlockUnaligned(ref b, 0, (uint)byteLength);
				return;
			}
			ulong num = (ulong)byteLength;
			uint num2 = (uint)(num & 0xFFFFFFFFu);
			Unsafe.InitBlockUnaligned(ref b, 0, num2);
			num -= num2;
			long num3 = num2;
			while (num != 0)
			{
				num2 = (uint)((num >= uint.MaxValue) ? uint.MaxValue : num);
				Unsafe.InitBlockUnaligned(ref Unsafe.Add(ref b, (IntPtr)num3), 0, num2);
				num3 += num2;
				num -= num2;
			}
		}

		public unsafe static void ClearPointerSizedWithoutReferences(ref byte b, UIntPtr byteLength)
		{
			IntPtr zero;
			for (zero = IntPtr.Zero; zero.LessThanEqual(byteLength - sizeof(Reg64)); zero += sizeof(Reg64))
			{
				Unsafe.As<byte, Reg64>(ref Unsafe.Add(ref b, zero)) = default(Reg64);
			}
			if (zero.LessThanEqual(byteLength - sizeof(Reg32)))
			{
				Unsafe.As<byte, Reg32>(ref Unsafe.Add(ref b, zero)) = default(Reg32);
				zero += sizeof(Reg32);
			}
			if (zero.LessThanEqual(byteLength - sizeof(Reg16)))
			{
				Unsafe.As<byte, Reg16>(ref Unsafe.Add(ref b, zero)) = default(Reg16);
				zero += sizeof(Reg16);
			}
			if (zero.LessThanEqual(byteLength - 8))
			{
				Unsafe.As<byte, long>(ref Unsafe.Add(ref b, zero)) = 0L;
				zero += 8;
			}
			if (sizeof(IntPtr) == 4 && zero.LessThanEqual(byteLength - 4))
			{
				Unsafe.As<byte, int>(ref Unsafe.Add(ref b, zero)) = 0;
				zero += 4;
			}
		}

		public static void ClearPointerSizedWithReferences(ref IntPtr ip, UIntPtr pointerSizeLength)
		{
			IntPtr intPtr = IntPtr.Zero;
			IntPtr zero = IntPtr.Zero;
			while ((zero = intPtr + 8).LessThanEqual(pointerSizeLength))
			{
				Unsafe.Add(ref ip, intPtr + 0) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 1) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 2) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 3) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 4) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 5) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 6) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 7) = default(IntPtr);
				intPtr = zero;
			}
			if ((zero = intPtr + 4).LessThanEqual(pointerSizeLength))
			{
				Unsafe.Add(ref ip, intPtr + 0) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 1) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 2) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 3) = default(IntPtr);
				intPtr = zero;
			}
			if ((zero = intPtr + 2).LessThanEqual(pointerSizeLength))
			{
				Unsafe.Add(ref ip, intPtr + 0) = default(IntPtr);
				Unsafe.Add(ref ip, intPtr + 1) = default(IntPtr);
				intPtr = zero;
			}
			if ((intPtr + 1).LessThanEqual(pointerSizeLength))
			{
				Unsafe.Add(ref ip, intPtr) = default(IntPtr);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private unsafe static bool LessThanEqual(this IntPtr index, UIntPtr length)
		{
			if (sizeof(UIntPtr) != 4)
			{
				return (long)index <= (long)(ulong)length;
			}
			return (int)index <= (int)(uint)length;
		}
	}
	internal struct NUInt
	{
		private unsafe readonly void* _value;

		private unsafe NUInt(uint value)
		{
			_value = (void*)value;
		}

		private unsafe NUInt(ulong value)
		{
			_value = (void*)value;
		}

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

		public unsafe static implicit operator IntPtr(NUInt value)
		{
			return (IntPtr)value._value;
		}

		public static explicit operator NUInt(int value)
		{
			return new NUInt((uint)value);
		}

		public unsafe static explicit operator void*(NUInt value)
		{
			return value._value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static NUInt operator *(NUInt left, NUInt right)
		{
			if (sizeof(IntPtr) != 4)
			{
				return new NUInt((ulong)left._value * (ulong)right._value);
			}
			return new NUInt((uint)((int)left._value * (int)right._value));
		}
	}
	[StructLayout(LayoutKind.Sequential)]
	internal sealed class Pinnable<T>
	{
		public T Data;
	}
	internal static class NotImplemented
	{
		internal static Exception ByDesign => new NotImplementedException();

		internal static Exception ByDesignWithMessage(string message)
		{
			return new NotImplementedException(message);
		}

		internal static Exception ActiveIssue(string issue)
		{
			return new NotImplementedException();
		}
	}
	internal struct MutableDecimal
	{
		public uint Flags;

		public uint High;

		public uint Low;

		public uint Mid;

		private const uint SignMask = 2147483648u;

		private const uint ScaleMask = 16711680u;

		private const int ScaleShift = 16;

		public bool IsNegative
		{
			get
			{
				return (Flags & 0x80000000u) != 0;
			}
			set
			{
				Flags = (Flags & 0x7FFFFFFFu) | (value ? 2147483648u : 0u);
			}
		}

		public int Scale
		{
			get
			{
				return (byte)(Flags >> 16);
			}
			set
			{
				Flags = (Flags & 0xFF00FFFFu) | (uint)(value << 16);
			}
		}
	}
	internal static class <2cdd3d99-010c-4688-b500-482730d0e75a>SR
	{
		private static ResourceManager s_resourceManager;

		private static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(ResourceType));

		internal static Type ResourceType { get; } = typeof(FxResources.System.Memory.SR);


		internal static string NotSupported_CannotCallEqualsOnSpan => GetResourceString("NotSupported_CannotCallEqualsOnSpan", null);

		internal static string NotSupported_CannotCallGetHashCodeOnSpan => GetResourceString("NotSupported_CannotCallGetHashCodeOnSpan", null);

		internal static string Argument_InvalidTypeWithPointersNotSupported => GetResourceString("Argument_InvalidTypeWithPointersNotSupported", null);

		internal static string Argument_DestinationTooShort => GetResourceString("Argument_DestinationTooShort", null);

		internal static string MemoryDisposed => GetResourceString("MemoryDisposed", null);

		internal static string OutstandingReferences => GetResourceString("OutstandingReferences", null);

		internal static string Argument_BadFormatSpecifier => GetResourceString("Argument_BadFormatSpecifier", null);

		internal static string Argument_GWithPrecisionNotSupported => GetResourceString("Argument_GWithPrecisionNotSupported", null);

		internal static string Argument_CannotParsePrecision => GetResourceString("Argument_CannotParsePrecision", null);

		internal static string Argument_PrecisionTooLarge => GetResourceString("Argument_PrecisionTooLarge", null);

		internal static string Argument_OverlapAlignmentMismatch => GetResourceString("Argument_OverlapAlignmentMismatch", null);

		internal static string EndPositionNotReached => GetResourceString("EndPositionNotReached", null);

		internal static string UnexpectedSegmentType => GetResourceString("UnexpectedSegmentType", null);

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool UsingResourceKeys()
		{
			return false;
		}

		internal static string GetResourceString(string resourceKey, string defaultString)
		{
			string text = null;
			try
			{
				text = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			if (defaultString != null && resourceKey.Equals(text, StringComparison.Ordinal))
			{
				return defaultString;
			}
			return text;
		}

		internal static string Format(string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}
	}
}
namespace System.Numerics.Hashing
{
	internal static class HashHelpers
	{
		public static readonly int RandomSeed = Guid.NewGuid().GetHashCode();

		public static int Combine(int h1, int h2)
		{
			uint num = (uint)(h1 << 5) | ((uint)h1 >> 27);
			return ((int)num + h1) ^ h2;
		}
	}
}
namespace System.Runtime.InteropServices
{
	internal static class SequenceMarshal
	{
		public static bool TryGetReadOnlySequenceSegment<T>(ReadOnlySequence<T> sequence, out ReadOnlySequenceSegment<T> startSegment, out int startIndex, out ReadOnlySequenceSegment<T> endSegment, out int endIndex)
		{
			return sequence.TryGetReadOnlySequenceSegment(out startSegment, out startIndex, out endSegment, out endIndex);
		}

		public static bool TryGetArray<T>(ReadOnlySequence<T> sequence, out ArraySegment<T> segment)
		{
			return sequence.TryGetArray(out segment);
		}

		public static bool TryGetReadOnlyMemory<T>(ReadOnlySequence<T> sequence, out ReadOnlyMemory<T> memory)
		{
			if (!sequence.IsSingleSegment)
			{
				memory = default(ReadOnlyMemory<T>);
				return false;
			}
			memory = sequence.First;
			return true;
		}

		internal static bool TryGetString(ReadOnlySequence<char> sequence, out string text, out int start, out int length)
		{
			return sequence.TryGetString(out text, out start, out length);
		}
	}
	internal static class MemoryMarshal
	{
		public static bool TryGetArray<T>(ReadOnlyMemory<T> memory, out ArraySegment<T> segment)
		{
			int start;
			int length;
			object objectStartLength = memory.GetObjectStartLength(out start, out length);
			if (start < 0)
			{
				if (((MemoryManager<T>)objectStartLength).TryGetArray(out var segment2))
				{
					segment = new ArraySegment<T>(segment2.Array, segment2.Offset + (start & 0x7FFFFFFF), length);
					return true;
				}
			}
			else if (objectStartLength is T[] array)
			{
				segment = new ArraySegment<T>(array, start, length & 0x7FFFFFFF);
				return true;
			}
			if ((length & 0x7FFFFFFF) == 0)
			{
				segment = new ArraySegment<T>(System.SpanHelpers.PerTypeValues<T>.EmptyArray);
				return true;
			}
			segment = default(ArraySegment<T>);
			return false;
		}

		public static bool TryGetMemoryManager<T, TManager>(ReadOnlyMemory<T> memory, out TManager manager) where TManager : MemoryManager<T>
		{
			int start;
			int length;
			TManager val = (manager = memory.GetObjectStartLength(out start, out length) as TManager);
			return manager != null;
		}

		public static bool TryGetMemoryManager<T, TManager>(ReadOnlyMemory<T> memory, out TManager manager, out int start, out int length) where TManager : MemoryManager<T>
		{
			TManager val = (manager = memory.GetObjectStartLength(out start, out length) as TManager);
			start &= int.MaxValue;
			if (manager == null)
			{
				start = 0;
				length = 0;
				return false;
			}
			return true;
		}

		public static IEnumerable<T> ToEnumerable<T>(ReadOnlyMemory<T> memory)
		{
			for (int i = 0; i < memory.Length; i++)
			{
				yield return memory.Span[i];
			}
		}

		public static bool TryGetString(ReadOnlyMemory<char> memory, out string text, out int start, out int length)
		{
			if (memory.GetObjectStartLength(out var start2, out var length2) is string text2)
			{
				text = text2;
				start = start2;
				length = length2;
				return true;
			}
			text = null;
			start = 0;
			length = 0;
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T Read<T>(ReadOnlySpan<byte> source) where T : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > source.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			return Unsafe.ReadUnaligned<T>(ref GetReference(source));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryRead<T>(ReadOnlySpan<byte> source, out T value) where T : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > (uint)source.Length)
			{
				value = default(T);
				return false;
			}
			value = Unsafe.ReadUnaligned<T>(ref GetReference(source));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Write<T>(Span<byte> destination, ref T value) where T : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			if ((uint)Unsafe.SizeOf<T>() > (uint)destination.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			Unsafe.WriteUnaligned(ref GetReference(destination), value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWrite<T>(Span<byte> destination, ref T value) where T : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			if (Unsafe.SizeOf<T>() > (uint)destination.Length)
			{
				return false;
			}
			Unsafe.WriteUnaligned(ref GetReference(destination), value);
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Memory<T> CreateFromPinnedArray<T>(T[] array, int start, int length)
		{
			if (array == null)
			{
				if (start != 0 || length != 0)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException();
				}
				return default(Memory<T>);
			}
			if (default(T) == null && array.GetType() != typeof(T[]))
			{
				System.ThrowHelper.ThrowArrayTypeMismatchException();
			}
			if ((uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException();
			}
			return new Memory<T>((object)array, start, length | int.MinValue);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Span<byte> AsBytes<T>(Span<T> span) where T : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			int length = checked(span.Length * Unsafe.SizeOf<T>());
			return new Span<byte>(Unsafe.As<Pinnable<byte>>(span.Pinnable), span.ByteOffset, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadOnlySpan<byte> AsBytes<T>(ReadOnlySpan<T> span) where T : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<T>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(T));
			}
			int length = checked(span.Length * Unsafe.SizeOf<T>());
			return new ReadOnlySpan<byte>(Unsafe.As<Pinnable<byte>>(span.Pinnable), span.ByteOffset, length);
		}

		public static Memory<T> AsMemory<T>(ReadOnlyMemory<T> memory)
		{
			return Unsafe.As<ReadOnlyMemory<T>, Memory<T>>(ref memory);
		}

		public unsafe static ref T GetReference<T>(Span<T> span)
		{
			if (span.Pinnable == null)
			{
				return ref Unsafe.AsRef<T>(span.ByteOffset.ToPointer());
			}
			return ref Unsafe.AddByteOffset(ref span.Pinnable.Data, span.ByteOffset);
		}

		public unsafe static ref T GetReference<T>(ReadOnlySpan<T> span)
		{
			if (span.Pinnable == null)
			{
				return ref Unsafe.AsRef<T>(span.ByteOffset.ToPointer());
			}
			return ref Unsafe.AddByteOffset(ref span.Pinnable.Data, span.ByteOffset);
		}

		public static Span<TTo> Cast<TFrom, TTo>(Span<TFrom> span) where TFrom : struct where TTo : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<TFrom>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(TFrom));
			}
			if (System.SpanHelpers.IsReferenceOrContainsReferences<TTo>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(TTo));
			}
			checked
			{
				int length = (int)unchecked(checked(unchecked((long)span.Length) * unchecked((long)Unsafe.SizeOf<TFrom>())) / Unsafe.SizeOf<TTo>());
				return new Span<TTo>(Unsafe.As<Pinnable<TTo>>(span.Pinnable), span.ByteOffset, length);
			}
		}

		public static ReadOnlySpan<TTo> Cast<TFrom, TTo>(ReadOnlySpan<TFrom> span) where TFrom : struct where TTo : struct
		{
			if (System.SpanHelpers.IsReferenceOrContainsReferences<TFrom>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(TFrom));
			}
			if (System.SpanHelpers.IsReferenceOrContainsReferences<TTo>())
			{
				System.ThrowHelper.ThrowArgumentException_InvalidTypeWithPointersNotSupported(typeof(TTo));
			}
			checked
			{
				int length = (int)unchecked(checked(unchecked((long)span.Length) * unchecked((long)Unsafe.SizeOf<TFrom>())) / Unsafe.SizeOf<TTo>());
				return new ReadOnlySpan<TTo>(Unsafe.As<Pinnable<TTo>>(span.Pinnable), span.ByteOffset, length);
			}
		}
	}
}
namespace System.Buffers
{
	internal sealed class ArrayMemoryPool<T> : MemoryPool<T>
	{
		private sealed class ArrayMemoryPoolBuffer : IMemoryOwner<T>, IDisposable
		{
			private T[] _array;

			public Memory<T> Memory
			{
				get
				{
					T[] array = _array;
					if (array == null)
					{
						System.ThrowHelper.ThrowObjectDisposedException_ArrayMemoryPoolBuffer();
					}
					return new Memory<T>(array);
				}
			}

			public ArrayMemoryPoolBuffer(int size)
			{
				_array = ArrayPool<T>.Shared.Rent(size);
			}

			public void Dispose()
			{
				T[] array = _array;
				if (array != null)
				{
					_array = null;
					ArrayPool<T>.Shared.Return(array);
				}
			}
		}

		private const int s_maxBufferSize = int.MaxValue;

		public sealed override int MaxBufferSize => int.MaxValue;

		public sealed override IMemoryOwner<T> Rent(int minimumBufferSize = -1)
		{
			if (minimumBufferSize == -1)
			{
				minimumBufferSize = 1 + 4095 / Unsafe.SizeOf<T>();
			}
			else if ((uint)minimumBufferSize > 2147483647u)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.minimumBufferSize);
			}
			return new ArrayMemoryPoolBuffer(minimumBufferSize);
		}

		protected sealed override void Dispose(bool disposing)
		{
		}
	}
	internal static class BuffersExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SequencePosition? PositionOf<T>([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] this ref ReadOnlySequence<T> source, T value) where T : IEquatable<T>
		{
			if (source.IsSingleSegment)
			{
				int num = source.First.Span.IndexOf(value);
				if (num != -1)
				{
					return source.GetPosition(num);
				}
				return null;
			}
			return PositionOfMultiSegment(ref source, value);
		}

		private static SequencePosition? PositionOfMultiSegment<T>([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref ReadOnlySequence<T> source, T value) where T : IEquatable<T>
		{
			SequencePosition position = source.Start;
			SequencePosition origin = position;
			ReadOnlyMemory<T> memory;
			while (source.TryGet(ref position, out memory))
			{
				int num = memory.Span.IndexOf(value);
				if (num != -1)
				{
					return source.GetPosition(num, origin);
				}
				if (position.GetObject() == null)
				{
					break;
				}
				origin = position;
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void CopyTo<T>([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] this ref ReadOnlySequence<T> source, Span<T> destination)
		{
			if (source.Length > destination.Length)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.destination);
			}
			if (source.IsSingleSegment)
			{
				source.First.Span.CopyTo(destination);
			}
			else
			{
				CopyToMultiSegment(ref source, destination);
			}
		}

		private static void CopyToMultiSegment<T>([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref ReadOnlySequence<T> sequence, Span<T> destination)
		{
			SequencePosition position = sequence.Start;
			ReadOnlyMemory<T> memory;
			while (sequence.TryGet(ref position, out memory))
			{
				ReadOnlySpan<T> span = memory.Span;
				span.CopyTo(destination);
				if (position.GetObject() != null)
				{
					destination = destination.Slice(span.Length);
					continue;
				}
				break;
			}
		}

		public static T[] ToArray<T>([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] this ref ReadOnlySequence<T> sequence)
		{
			T[] array = new T[sequence.Length];
			CopyTo(ref sequence, array);
			return array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void Write<T>(this IBufferWriter<T> writer, ReadOnlySpan<T> value)
		{
			Span<T> span = writer.GetSpan();
			if (value.Length <= span.Length)
			{
				value.CopyTo(span);
				writer.Advance(value.Length);
			}
			else
			{
				WriteMultiSegment(writer, ref value, span);
			}
		}

		private static void WriteMultiSegment<T>(IBufferWriter<T> writer, [In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref ReadOnlySpan<T> source, Span<T> destination)
		{
			ReadOnlySpan<T> readOnlySpan = source;
			while (true)
			{
				int num = Math.Min(destination.Length, readOnlySpan.Length);
				readOnlySpan.Slice(0, num).CopyTo(destination);
				writer.Advance(num);
				readOnlySpan = readOnlySpan.Slice(num);
				if (readOnlySpan.Length > 0)
				{
					destination = writer.GetSpan(readOnlySpan.Length);
					continue;
				}
				break;
			}
		}
	}
	internal interface IBufferWriter<T>
	{
		void Advance(int count);

		Memory<T> GetMemory(int sizeHint = 0);

		Span<T> GetSpan(int sizeHint = 0);
	}
	internal abstract class MemoryPool<T> : IDisposable
	{
		private static readonly MemoryPool<T> s_shared = new ArrayMemoryPool<T>();

		public static MemoryPool<T> Shared => s_shared;

		public abstract int MaxBufferSize { get; }

		public abstract IMemoryOwner<T> Rent(int minBufferSize = -1);

		public void Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected abstract void Dispose(bool disposing);
	}
	internal enum OperationStatus
	{
		Done,
		DestinationTooSmall,
		NeedMoreData,
		InvalidData
	}
	[DebuggerDisplay("{ToString(),raw}")]
	[DebuggerTypeProxy(typeof(ReadOnlySequenceDebugView<>))]
	[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
	internal struct ReadOnlySequence<T>
	{
		public struct Enumerator
		{
			private readonly ReadOnlySequence<T> _sequence;

			private SequencePosition _next;

			private ReadOnlyMemory<T> _currentMemory;

			public ReadOnlyMemory<T> Current => _currentMemory;

			public Enumerator([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref ReadOnlySequence<T> sequence)
			{
				_currentMemory = default(ReadOnlyMemory<T>);
				_next = sequence.Start;
				_sequence = sequence;
			}

			public bool MoveNext()
			{
				if (_next.GetObject() == null)
				{
					return false;
				}
				return _sequence.TryGet(ref _next, out _currentMemory);
			}
		}

		private enum SequenceType
		{
			MultiSegment,
			Array,
			MemoryManager,
			String,
			Empty
		}

		private readonly SequencePosition _sequenceStart;

		private readonly SequencePosition _sequenceEnd;

		public static readonly ReadOnlySequence<T> Empty = new ReadOnlySequence<T>(System.SpanHelpers.PerTypeValues<T>.EmptyArray);

		public long Length => GetLength();

		public bool IsEmpty => Length == 0;

		public bool IsSingleSegment
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _sequenceStart.GetObject() == _sequenceEnd.GetObject();
			}
		}

		public ReadOnlyMemory<T> First => GetFirstBuffer();

		public SequencePosition Start => _sequenceStart;

		public SequencePosition End => _sequenceEnd;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ReadOnlySequence(object startSegment, int startIndexAndFlags, object endSegment, int endIndexAndFlags)
		{
			_sequenceStart = new SequencePosition(startSegment, startIndexAndFlags);
			_sequenceEnd = new SequencePosition(endSegment, endIndexAndFlags);
		}

		public ReadOnlySequence(ReadOnlySequenceSegment<T> startSegment, int startIndex, ReadOnlySequenceSegment<T> endSegment, int endIndex)
		{
			if (startSegment == null || endSegment == null || (startSegment != endSegment && startSegment.RunningIndex > endSegment.RunningIndex) || (uint)startSegment.Memory.Length < (uint)startIndex || (uint)endSegment.Memory.Length < (uint)endIndex || (startSegment == endSegment && endIndex < startIndex))
			{
				System.ThrowHelper.ThrowArgumentValidationException(startSegment, startIndex, endSegment);
			}
			_sequenceStart = new SequencePosition(startSegment, ReadOnlySequence.SegmentToSequenceStart(startIndex));
			_sequenceEnd = new SequencePosition(endSegment, ReadOnlySequence.SegmentToSequenceEnd(endIndex));
		}

		public ReadOnlySequence(T[] array)
		{
			if (array == null)
			{
				System.ThrowHelper.ThrowArgumentNullException(System.ExceptionArgument.array);
			}
			_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(0));
			_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(array.Length));
		}

		public ReadOnlySequence(T[] array, int start, int length)
		{
			if (array == null || (uint)start > (uint)array.Length || (uint)length > (uint)(array.Length - start))
			{
				System.ThrowHelper.ThrowArgumentValidationException(array, start);
			}
			_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(start));
			_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(start + length));
		}

		public ReadOnlySequence(ReadOnlyMemory<T> memory)
		{
			ArraySegment<T> segment;
			if (MemoryMarshal.TryGetMemoryManager<T, MemoryManager<T>>(memory, out var manager, out var start, out var length))
			{
				_sequenceStart = new SequencePosition(manager, ReadOnlySequence.MemoryManagerToSequenceStart(start));
				_sequenceEnd = new SequencePosition(manager, ReadOnlySequence.MemoryManagerToSequenceEnd(length));
			}
			else if (MemoryMarshal.TryGetArray(memory, out segment))
			{
				T[] array = segment.Array;
				int offset = segment.Offset;
				_sequenceStart = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceStart(offset));
				_sequenceEnd = new SequencePosition(array, ReadOnlySequence.ArrayToSequenceEnd(offset + segment.Count));
			}
			else if (typeof(T) == typeof(char))
			{
				if (!MemoryMarshal.TryGetString((ReadOnlyMemory<char>)(object)memory, out var text, out var start2, out length))
				{
					System.ThrowHelper.ThrowInvalidOperationException();
				}
				_sequenceStart = new SequencePosition(text, ReadOnlySequence.StringToSequenceStart(start2));
				_sequenceEnd = new SequencePosition(text, ReadOnlySequence.StringToSequenceEnd(start2 + length));
			}
			else
			{
				System.ThrowHelper.ThrowInvalidOperationException();
				_sequenceStart = default(SequencePosition);
				_sequenceEnd = default(SequencePosition);
			}
		}

		public ReadOnlySequence<T> Slice(long start, long length)
		{
			if (start < 0 || length < 0)
			{
				System.ThrowHelper.ThrowStartOrEndArgumentValidationException(start);
			}
			int index = GetIndex(ref _sequenceStart);
			int index2 = GetIndex(ref _sequenceEnd);
			object @object = _sequenceStart.GetObject();
			object object2 = _sequenceEnd.GetObject();
			SequencePosition start2;
			SequencePosition end;
			if (@object != object2)
			{
				ReadOnlySequenceSegment<T> readOnlySequenceSegment = (ReadOnlySequenceSegment<T>)@object;
				int num = readOnlySequenceSegment.Memory.Length - index;
				if (num > start)
				{
					index += (int)start;
					start2 = new SequencePosition(@object, index);
					end = GetEndPosition(readOnlySequenceSegment, @object, index, object2, index2, length);
				}
				else
				{
					if (num < 0)
					{
						System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
					}
					start2 = SeekMultiSegment(readOnlySequenceSegment.Next, object2, index2, start - num, System.ExceptionArgument.start);
					int index3 = GetIndex(ref start2);
					object object3 = start2.GetObject();
					if (object3 != object2)
					{
						end = GetEndPosition((ReadOnlySequenceSegment<T>)object3, object3, index3, object2, index2, length);
					}
					else
					{
						if (index2 - index3 < length)
						{
							System.ThrowHelper.ThrowStartOrEndArgumentValidationException(0L);
						}
						end = new SequencePosition(object3, index3 + (int)length);
					}
				}
			}
			else
			{
				if (index2 - index < start)
				{
					System.ThrowHelper.ThrowStartOrEndArgumentValidationException(-1L);
				}
				index += (int)start;
				start2 = new SequencePosition(@object, index);
				if (index2 - index < length)
				{
					System.ThrowHelper.ThrowStartOrEndArgumentValidationException(0L);
				}
				end = new SequencePosition(@object, index + (int)length);
			}
			return SliceImpl(ref start2, ref end);
		}

		public ReadOnlySequence<T> Slice(long start, SequencePosition end)
		{
			if (start < 0)
			{
				System.ThrowHelper.ThrowStartOrEndArgumentValidationException(start);
			}
			uint index = (uint)GetIndex(ref end);
			object @object = end.GetObject();
			uint index2 = (uint)GetIndex(ref _sequenceStart);
			object object2 = _sequenceStart.GetObject();
			uint index3 = (uint)GetIndex(ref _sequenceEnd);
			object object3 = _sequenceEnd.GetObject();
			if (object2 == object3)
			{
				if (!InRange(index, index2, index3))
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
				}
				if (index - index2 < start)
				{
					System.ThrowHelper.ThrowStartOrEndArgumentValidationException(-1L);
				}
			}
			else
			{
				ReadOnlySequenceSegment<T> readOnlySequenceSegment = (ReadOnlySequenceSegment<T>)object2;
				ulong num = (ulong)(readOnlySequenceSegment.RunningIndex + index2);
				ulong num2 = (ulong)(((ReadOnlySequenceSegment<T>)@object).RunningIndex + index);
				if (!InRange(num2, num, (ulong)(((ReadOnlySequenceSegment<T>)object3).RunningIndex + index3)))
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
				}
				if ((ulong)((long)num + start) > num2)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.start);
				}
				int num3 = readOnlySequenceSegment.Memory.Length - (int)index2;
				if (num3 <= start)
				{
					if (num3 < 0)
					{
						System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
					}
					SequencePosition start2 = SeekMultiSegment(readOnlySequenceSegment.Next, @object, (int)index, start - num3, System.ExceptionArgument.start);
					return SliceImpl(ref start2, ref end);
				}
			}
			SequencePosition start3 = new SequencePosition(object2, (int)index2 + (int)start);
			return SliceImpl(ref start3, ref end);
		}

		public ReadOnlySequence<T> Slice(SequencePosition start, long length)
		{
			uint index = (uint)GetIndex(ref start);
			object @object = start.GetObject();
			uint index2 = (uint)GetIndex(ref _sequenceStart);
			object object2 = _sequenceStart.GetObject();
			uint index3 = (uint)GetIndex(ref _sequenceEnd);
			object object3 = _sequenceEnd.GetObject();
			if (object2 == object3)
			{
				if (!InRange(index, index2, index3))
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
				}
				if (length < 0)
				{
					System.ThrowHelper.ThrowStartOrEndArgumentValidationException(0L);
				}
				if (index3 - index < length)
				{
					System.ThrowHelper.ThrowStartOrEndArgumentValidationException(0L);
				}
			}
			else
			{
				ReadOnlySequenceSegment<T> readOnlySequenceSegment = (ReadOnlySequenceSegment<T>)@object;
				ulong num = (ulong)(readOnlySequenceSegment.RunningIndex + index);
				ulong start2 = (ulong)(((ReadOnlySequenceSegment<T>)object2).RunningIndex + index2);
				ulong num2 = (ulong)(((ReadOnlySequenceSegment<T>)object3).RunningIndex + index3);
				if (!InRange(num, start2, num2))
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
				}
				if (length < 0)
				{
					System.ThrowHelper.ThrowStartOrEndArgumentValidationException(0L);
				}
				if ((ulong)((long)num + length) > num2)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
				}
				int num3 = readOnlySequenceSegment.Memory.Length - (int)index;
				if (num3 < length)
				{
					if (num3 < 0)
					{
						System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
					}
					SequencePosition end = SeekMultiSegment(readOnlySequenceSegment.Next, object3, (int)index3, length - num3, System.ExceptionArgument.length);
					return SliceImpl(ref start, ref end);
				}
			}
			SequencePosition end2 = new SequencePosition(@object, (int)index + (int)length);
			return SliceImpl(ref start, ref end2);
		}

		public ReadOnlySequence<T> Slice(int start, int length)
		{
			return Slice((long)start, (long)length);
		}

		public ReadOnlySequence<T> Slice(int start, SequencePosition end)
		{
			return Slice((long)start, end);
		}

		public ReadOnlySequence<T> Slice(SequencePosition start, int length)
		{
			return Slice(start, (long)length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySequence<T> Slice(SequencePosition start, SequencePosition end)
		{
			BoundsCheck((uint)GetIndex(ref start), start.GetObject(), (uint)GetIndex(ref end), end.GetObject());
			return SliceImpl(ref start, ref end);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ReadOnlySequence<T> Slice(SequencePosition start)
		{
			BoundsCheck(ref start);
			return SliceImpl(ref start, ref _sequenceEnd);
		}

		public ReadOnlySequence<T> Slice(long start)
		{
			if (start < 0)
			{
				System.ThrowHelper.ThrowStartOrEndArgumentValidationException(start);
			}
			if (start == 0L)
			{
				return this;
			}
			SequencePosition start2 = Seek(ref _sequenceStart, ref _sequenceEnd, start, System.ExceptionArgument.start);
			return SliceImpl(ref start2, ref _sequenceEnd);
		}

		public override string ToString()
		{
			if (typeof(T) == typeof(char))
			{
				ReadOnlySequence<T> source = this;
				ReadOnlySequence<char> sequence = Unsafe.As<ReadOnlySequence<T>, ReadOnlySequence<char>>(ref source);
				if (SequenceMarshal.TryGetString(sequence, out var text, out var start, out var length))
				{
					return text.Substring(start, length);
				}
				if (Length < int.MaxValue)
				{
					return new string(BuffersExtensions.ToArray(ref sequence));
				}
			}
			return $"System.Buffers.ReadOnlySequence<{typeof(T).Name}>[{Length}]";
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(ref this);
		}

		public SequencePosition GetPosition(long offset)
		{
			return GetPosition(offset, _sequenceStart);
		}

		public SequencePosition GetPosition(long offset, SequencePosition origin)
		{
			if (offset < 0)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException_OffsetOutOfRange();
			}
			return Seek(ref origin, ref _sequenceEnd, offset, System.ExceptionArgument.offset);
		}

		public bool TryGet(ref SequencePosition position, out ReadOnlyMemory<T> memory, bool advance = true)
		{
			SequencePosition next;
			bool result = TryGetBuffer(ref position, out memory, out next);
			if (advance)
			{
				position = next;
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool TryGetBuffer([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref SequencePosition position, out ReadOnlyMemory<T> memory, out SequencePosition next)
		{
			object @object = position.GetObject();
			next = default(SequencePosition);
			if (@object == null)
			{
				memory = default(ReadOnlyMemory<T>);
				return false;
			}
			SequenceType sequenceType = GetSequenceType();
			object object2 = _sequenceEnd.GetObject();
			int index = GetIndex(ref position);
			int index2 = GetIndex(ref _sequenceEnd);
			if (sequenceType == SequenceType.MultiSegment)
			{
				ReadOnlySequenceSegment<T> readOnlySequenceSegment = (ReadOnlySequenceSegment<T>)@object;
				if (readOnlySequenceSegment != object2)
				{
					ReadOnlySequenceSegment<T> next2 = readOnlySequenceSegment.Next;
					if (next2 == null)
					{
						System.ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
					}
					next = new SequencePosition(next2, 0);
					memory = readOnlySequenceSegment.Memory.Slice(index);
				}
				else
				{
					memory = readOnlySequenceSegment.Memory.Slice(index, index2 - index);
				}
			}
			else
			{
				if (@object != object2)
				{
					System.ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
				}
				if (sequenceType == SequenceType.Array)
				{
					memory = new ReadOnlyMemory<T>((T[])@object, index, index2 - index);
				}
				else if (typeof(T) == typeof(char) && sequenceType == SequenceType.String)
				{
					memory = (ReadOnlyMemory<T>)(object)MemoryExtensions.AsMemory((string)@object, index, index2 - index);
				}
				else
				{
					memory = ((MemoryManager<T>)@object).Memory.Slice(index, index2 - index);
				}
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ReadOnlyMemory<T> GetFirstBuffer()
		{
			object @object = _sequenceStart.GetObject();
			if (@object == null)
			{
				return default(ReadOnlyMemory<T>);
			}
			int integer = _sequenceStart.GetInteger();
			int integer2 = _sequenceEnd.GetInteger();
			bool flag = @object != _sequenceEnd.GetObject();
			if (integer >= 0)
			{
				if (integer2 >= 0)
				{
					ReadOnlyMemory<T> memory = ((ReadOnlySequenceSegment<T>)@object).Memory;
					if (flag)
					{
						return memory.Slice(integer);
					}
					return memory.Slice(integer, integer2 - integer);
				}
				if (flag)
				{
					System.ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
				}
				return new ReadOnlyMemory<T>((T[])@object, integer, (integer2 & 0x7FFFFFFF) - integer);
			}
			if (flag)
			{
				System.ThrowHelper.ThrowInvalidOperationException_EndPositionNotReached();
			}
			if (typeof(T) == typeof(char) && integer2 < 0)
			{
				return (ReadOnlyMemory<T>)(object)MemoryExtensions.AsMemory((string)@object, integer & 0x7FFFFFFF, integer2 - integer);
			}
			integer &= 0x7FFFFFFF;
			return ((MemoryManager<T>)@object).Memory.Slice(integer, integer2 - integer);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private SequencePosition Seek([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref SequencePosition start, [In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref SequencePosition end, long offset, System.ExceptionArgument argument)
		{
			int index = GetIndex(ref start);
			int index2 = GetIndex(ref end);
			object @object = start.GetObject();
			object object2 = end.GetObject();
			if (@object != object2)
			{
				ReadOnlySequenceSegment<T> readOnlySequenceSegment = (ReadOnlySequenceSegment<T>)@object;
				int num = readOnlySequenceSegment.Memory.Length - index;
				if (num <= offset)
				{
					if (num < 0)
					{
						System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
					}
					return SeekMultiSegment(readOnlySequenceSegment.Next, object2, index2, offset - num, argument);
				}
			}
			else if (index2 - index < offset)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(argument);
			}
			return new SequencePosition(@object, index + (int)offset);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static SequencePosition SeekMultiSegment(ReadOnlySequenceSegment<T> currentSegment, object endObject, int endIndex, long offset, System.ExceptionArgument argument)
		{
			while (true)
			{
				if (currentSegment != null && currentSegment != endObject)
				{
					int length = currentSegment.Memory.Length;
					if (length > offset)
					{
						break;
					}
					offset -= length;
					currentSegment = currentSegment.Next;
					continue;
				}
				if (currentSegment == null || endIndex < offset)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException(argument);
				}
				break;
			}
			return new SequencePosition(currentSegment, (int)offset);
		}

		private void BoundsCheck([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref SequencePosition position)
		{
			uint index = (uint)GetIndex(ref position);
			uint index2 = (uint)GetIndex(ref _sequenceStart);
			uint index3 = (uint)GetIndex(ref _sequenceEnd);
			object @object = _sequenceStart.GetObject();
			object object2 = _sequenceEnd.GetObject();
			if (@object == object2)
			{
				if (!InRange(index, index2, index3))
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
				}
				return;
			}
			ulong start = (ulong)(((ReadOnlySequenceSegment<T>)@object).RunningIndex + index2);
			if (!InRange((ulong)(((ReadOnlySequenceSegment<T>)position.GetObject()).RunningIndex + index), start, (ulong)(((ReadOnlySequenceSegment<T>)object2).RunningIndex + index3)))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
			}
		}

		private void BoundsCheck(uint sliceStartIndex, object sliceStartObject, uint sliceEndIndex, object sliceEndObject)
		{
			uint index = (uint)GetIndex(ref _sequenceStart);
			uint index2 = (uint)GetIndex(ref _sequenceEnd);
			object @object = _sequenceStart.GetObject();
			object object2 = _sequenceEnd.GetObject();
			if (@object == object2)
			{
				if (sliceStartObject != sliceEndObject || sliceStartObject != @object || sliceStartIndex > sliceEndIndex || sliceStartIndex < index || sliceEndIndex > index2)
				{
					System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
				}
				return;
			}
			ulong num = (ulong)(((ReadOnlySequenceSegment<T>)sliceStartObject).RunningIndex + sliceStartIndex);
			ulong num2 = (ulong)(((ReadOnlySequenceSegment<T>)sliceEndObject).RunningIndex + sliceEndIndex);
			if (num > num2)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
			}
			if (num < (ulong)(((ReadOnlySequenceSegment<T>)@object).RunningIndex + index) || num2 > (ulong)(((ReadOnlySequenceSegment<T>)object2).RunningIndex + index2))
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
			}
		}

		private static SequencePosition GetEndPosition(ReadOnlySequenceSegment<T> startSegment, object startObject, int startIndex, object endObject, int endIndex, long length)
		{
			int num = startSegment.Memory.Length - startIndex;
			if (num > length)
			{
				return new SequencePosition(startObject, startIndex + (int)length);
			}
			if (num < 0)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException_PositionOutOfRange();
			}
			return SeekMultiSegment(startSegment.Next, endObject, endIndex, length - num, System.ExceptionArgument.length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private SequenceType GetSequenceType()
		{
			return (SequenceType)(-(2 * (_sequenceStart.GetInteger() >> 31) + (_sequenceEnd.GetInteger() >> 31)));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int GetIndex([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref SequencePosition position)
		{
			return position.GetInteger() & 0x7FFFFFFF;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private ReadOnlySequence<T> SliceImpl([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref SequencePosition start, [In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref SequencePosition end)
		{
			return new ReadOnlySequence<T>(start.GetObject(), GetIndex(ref start) | (_sequenceStart.GetInteger() & int.MinValue), end.GetObject(), GetIndex(ref end) | (_sequenceEnd.GetInteger() & int.MinValue));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private long GetLength()
		{
			int index = GetIndex(ref _sequenceStart);
			int index2 = GetIndex(ref _sequenceEnd);
			object @object = _sequenceStart.GetObject();
			object object2 = _sequenceEnd.GetObject();
			if (@object != object2)
			{
				ReadOnlySequenceSegment<T> readOnlySequenceSegment = (ReadOnlySequenceSegment<T>)@object;
				ReadOnlySequenceSegment<T> readOnlySequenceSegment2 = (ReadOnlySequenceSegment<T>)object2;
				return readOnlySequenceSegment2.RunningIndex + index2 - (readOnlySequenceSegment.RunningIndex + index);
			}
			return index2 - index;
		}

		internal bool TryGetReadOnlySequenceSegment(out ReadOnlySequenceSegment<T> startSegment, out int startIndex, out ReadOnlySequenceSegment<T> endSegment, out int endIndex)
		{
			object @object = _sequenceStart.GetObject();
			if (@object == null || GetSequenceType() != 0)
			{
				startSegment = null;
				startIndex = 0;
				endSegment = null;
				endIndex = 0;
				return false;
			}
			startSegment = (ReadOnlySequenceSegment<T>)@object;
			startIndex = GetIndex(ref _sequenceStart);
			endSegment = (ReadOnlySequenceSegment<T>)_sequenceEnd.GetObject();
			endIndex = GetIndex(ref _sequenceEnd);
			return true;
		}

		internal bool TryGetArray(out ArraySegment<T> segment)
		{
			if (GetSequenceType() != SequenceType.Array)
			{
				segment = default(ArraySegment<T>);
				return false;
			}
			int index = GetIndex(ref _sequenceStart);
			segment = new ArraySegment<T>((T[])_sequenceStart.GetObject(), index, GetIndex(ref _sequenceEnd) - index);
			return true;
		}

		internal bool TryGetString(out string text, out int start, out int length)
		{
			if (typeof(T) != typeof(char) || GetSequenceType() != SequenceType.String)
			{
				start = 0;
				length = 0;
				text = null;
				return false;
			}
			start = GetIndex(ref _sequenceStart);
			length = GetIndex(ref _sequenceEnd) - start;
			text = (string)_sequenceStart.GetObject();
			return true;
		}

		private static bool InRange(uint value, uint start, uint end)
		{
			return value - start <= end - start;
		}

		private static bool InRange(ulong value, ulong start, ulong end)
		{
			return value - start <= end - start;
		}
	}
	internal static class ReadOnlySequence
	{
		public const int FlagBitMask = int.MinValue;

		public const int IndexBitMask = int.MaxValue;

		public const int SegmentStartMask = 0;

		public const int SegmentEndMask = 0;

		public const int ArrayStartMask = 0;

		public const int ArrayEndMask = int.MinValue;

		public const int MemoryManagerStartMask = int.MinValue;

		public const int MemoryManagerEndMask = 0;

		public const int StringStartMask = int.MinValue;

		public const int StringEndMask = int.MinValue;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SegmentToSequenceStart(int startIndex)
		{
			return startIndex | 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int SegmentToSequenceEnd(int endIndex)
		{
			return endIndex | 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ArrayToSequenceStart(int startIndex)
		{
			return startIndex | 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ArrayToSequenceEnd(int endIndex)
		{
			return endIndex | int.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MemoryManagerToSequenceStart(int startIndex)
		{
			return startIndex | int.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int MemoryManagerToSequenceEnd(int endIndex)
		{
			return endIndex | 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int StringToSequenceStart(int startIndex)
		{
			return startIndex | int.MinValue;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int StringToSequenceEnd(int endIndex)
		{
			return endIndex | int.MinValue;
		}
	}
	internal sealed class ReadOnlySequenceDebugView<T>
	{
		[DebuggerDisplay("Count: {Segments.Length}", Name = "Segments")]
		public struct ReadOnlySequenceDebugViewSegments
		{
			[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
			public ReadOnlyMemory<T>[] Segments { get; set; }
		}

		private readonly T[] _array;

		private readonly ReadOnlySequenceDebugViewSegments _segments;

		public ReadOnlySequenceDebugViewSegments BufferSegments => _segments;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Items => _array;

		public ReadOnlySequenceDebugView(ReadOnlySequence<T> sequence)
		{
			_array = BuffersExtensions.ToArray(ref sequence);
			int num = 0;
			ReadOnlySequence<T>.Enumerator enumerator = sequence.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ReadOnlyMemory<T> current = enumerator.Current;
				num++;
			}
			ReadOnlyMemory<T>[] array = new ReadOnlyMemory<T>[num];
			int num2 = 0;
			ReadOnlySequence<T>.Enumerator enumerator2 = sequence.GetEnumerator();
			while (enumerator2.MoveNext())
			{
				ReadOnlyMemory<T> current2 = enumerator2.Current;
				array[num2] = current2;
				num2++;
			}
			_segments = new ReadOnlySequenceDebugViewSegments
			{
				Segments = array
			};
		}
	}
	internal abstract class ReadOnlySequenceSegment<T>
	{
		public ReadOnlyMemory<T> Memory { get; protected set; }

		public ReadOnlySequenceSegment<T> Next { get; protected set; }

		public long RunningIndex { get; protected set; }
	}
	[<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly]
	internal struct StandardFormat : IEquatable<StandardFormat>
	{
		public const byte NoPrecision = byte.MaxValue;

		public const byte MaxPrecision = 99;

		private readonly byte _format;

		private readonly byte _precision;

		public char Symbol => (char)_format;

		public byte Precision => _precision;

		public bool HasPrecision => _precision != byte.MaxValue;

		public bool IsDefault
		{
			get
			{
				if (_format == 0)
				{
					return _precision == 0;
				}
				return false;
			}
		}

		public StandardFormat(char symbol, byte precision = byte.MaxValue)
		{
			if (precision != byte.MaxValue && precision > 99)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException_PrecisionTooLarge();
			}
			if (symbol != (byte)symbol)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException_SymbolDoesNotFit();
			}
			_format = (byte)symbol;
			_precision = precision;
		}

		public static implicit operator StandardFormat(char symbol)
		{
			return new StandardFormat(symbol);
		}

		public static StandardFormat Parse(ReadOnlySpan<char> format)
		{
			if (format.Length == 0)
			{
				return default(StandardFormat);
			}
			char symbol = format[0];
			byte precision;
			if (format.Length == 1)
			{
				precision = byte.MaxValue;
			}
			else
			{
				uint num = 0u;
				for (int i = 1; i < format.Length; i++)
				{
					uint num2 = (uint)(format[i] - 48);
					if (num2 > 9)
					{
						throw new FormatException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Format(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_CannotParsePrecision, (byte)99));
					}
					num = num * 10 + num2;
					if (num > 99)
					{
						throw new FormatException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Format(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_PrecisionTooLarge, (byte)99));
					}
				}
				precision = (byte)num;
			}
			return new StandardFormat(symbol, precision);
		}

		public static StandardFormat Parse(string format)
		{
			if (format != null)
			{
				return Parse(MemoryExtensions.AsSpan(format));
			}
			return default(StandardFormat);
		}

		public override bool Equals(object obj)
		{
			if (obj is StandardFormat other)
			{
				return Equals(other);
			}
			return false;
		}

		public override int GetHashCode()
		{
			byte format = _format;
			int hashCode = format.GetHashCode();
			format = _precision;
			return hashCode ^ format.GetHashCode();
		}

		public bool Equals(StandardFormat other)
		{
			if (_format == other._format)
			{
				return _precision == other._precision;
			}
			return false;
		}

		public unsafe override string ToString()
		{
			char* ptr = stackalloc char[4];
			int length = 0;
			char symbol = Symbol;
			if (symbol != 0)
			{
				ptr[length++] = symbol;
				byte b = Precision;
				if (b != byte.MaxValue)
				{
					if (b >= 100)
					{
						ptr[length++] = (char)(48 + b / 100 % 10);
						b %= 100;
					}
					if (b >= 10)
					{
						ptr[length++] = (char)(48 + b / 10 % 10);
						b %= 10;
					}
					ptr[length++] = (char)(48 + b);
				}
			}
			return new string(ptr, 0, length);
		}

		public static bool operator ==(StandardFormat left, StandardFormat right)
		{
			return left.Equals(right);
		}

		public static bool operator !=(StandardFormat left, StandardFormat right)
		{
			return !left.Equals(right);
		}
	}
	internal interface IPinnable
	{
		MemoryHandle Pin(int elementIndex);

		void Unpin();
	}
	internal interface IMemoryOwner<T> : IDisposable
	{
		Memory<T> Memory { get; }
	}
	internal struct MemoryHandle : IDisposable
	{
		private unsafe void* _pointer;

		private GCHandle _handle;

		private IPinnable _pinnable;

		[CLSCompliant(false)]
		public unsafe void* Pointer => _pointer;

		[CLSCompliant(false)]
		public unsafe MemoryHandle(void* pointer, GCHandle handle = default(GCHandle), IPinnable pinnable = null)
		{
			_pointer = pointer;
			_handle = handle;
			_pinnable = pinnable;
		}

		public unsafe void Dispose()
		{
			if (_handle.IsAllocated)
			{
				_handle.Free();
			}
			if (_pinnable != null)
			{
				_pinnable.Unpin();
				_pinnable = null;
			}
			_pointer = null;
		}
	}
	internal abstract class MemoryManager<T> : IMemoryOwner<T>, IDisposable, IPinnable
	{
		public virtual Memory<T> Memory => new Memory<T>(this, GetSpan().Length);

		public abstract Span<T> GetSpan();

		public abstract MemoryHandle Pin(int elementIndex = 0);

		public abstract void Unpin();

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected Memory<T> CreateMemory(int length)
		{
			return new Memory<T>(this, length);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected Memory<T> CreateMemory(int start, int length)
		{
			return new Memory<T>(this, start, length);
		}

		protected internal virtual bool TryGetArray(out ArraySegment<T> segment)
		{
			segment = default(ArraySegment<T>);
			return false;
		}

		void IDisposable.Dispose()
		{
			Dispose(disposing: true);
			GC.SuppressFinalize(this);
		}

		protected abstract void Dispose(bool disposing);
	}
}
namespace System.Buffers.Text
{
	internal static class Base64
	{
		private static readonly sbyte[] s_decodingMap = new sbyte[256]
		{
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, 62, -1, -1, -1, 63, 52, 53,
			54, 55, 56, 57, 58, 59, 60, 61, -1, -1,
			-1, -1, -1, -1, -1, 0, 1, 2, 3, 4,
			5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
			15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
			25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
			29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
			39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
			49, 50, 51, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
			-1, -1, -1, -1, -1, -1
		};

		private static readonly byte[] s_encodingMap = new byte[64]
		{
			65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
			75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
			85, 86, 87, 88, 89, 90, 97, 98, 99, 100,
			101, 102, 103, 104, 105, 106, 107, 108, 109, 110,
			111, 112, 113, 114, 115, 116, 117, 118, 119, 120,
			121, 122, 48, 49, 50, 51, 52, 53, 54, 55,
			56, 57, 43, 47
		};

		private const byte EncodingPad = 61;

		private const int MaximumEncodeLength = 1610612733;

		public static OperationStatus DecodeFromUtf8(ReadOnlySpan<byte> utf8, Span<byte> bytes, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true)
		{
			ref byte reference = ref MemoryMarshal.GetReference(utf8);
			ref byte reference2 = ref MemoryMarshal.GetReference(bytes);
			int num = utf8.Length & -4;
			int length = bytes.Length;
			int num2 = 0;
			int num3 = 0;
			if (utf8.Length != 0)
			{
				ref sbyte reference3 = ref s_decodingMap[0];
				int num4 = (isFinalBlock ? 4 : 0);
				int num5 = 0;
				num5 = ((length < GetMaxDecodedFromUtf8Length(num)) ? (length / 3 * 4) : (num - num4));
				while (true)
				{
					if (num2 < num5)
					{
						int num6 = Decode(ref Unsafe.Add(ref reference, num2), ref reference3);
						if (num6 >= 0)
						{
							WriteThreeLowOrderBytes(ref Unsafe.Add(ref reference2, num3), num6);
							num3 += 3;
							num2 += 4;
							continue;
						}
					}
					else
					{
						if (num5 != num - num4)
						{
							goto IL_0205;
						}
						if (num2 == num)
						{
							if (!isFinalBlock)
							{
								bytesConsumed = num2;
								bytesWritten = num3;
								return OperationStatus.NeedMoreData;
							}
						}
						else
						{
							int elementOffset = Unsafe.Add(ref reference, num - 4);
							int elementOffset2 = Unsafe.Add(ref reference, num - 3);
							int num7 = Unsafe.Add(ref reference, num - 2);
							int num8 = Unsafe.Add(ref reference, num - 1);
							elementOffset = Unsafe.Add(ref reference3, elementOffset);
							elementOffset2 = Unsafe.Add(ref reference3, elementOffset2);
							elementOffset <<= 18;
							elementOffset2 <<= 12;
							elementOffset |= elementOffset2;
							if (num8 != 61)
							{
								num7 = Unsafe.Add(ref reference3, num7);
								num8 = Unsafe.Add(ref reference3, num8);
								num7 <<= 6;
								elementOffset |= num8;
								elementOffset |= num7;
								if (elementOffset >= 0)
								{
									if (num3 <= length - 3)
									{
										WriteThreeLowOrderBytes(ref Unsafe.Add(ref reference2, num3), elementOffset);
										num3 += 3;
										goto IL_01eb;
									}
									goto IL_0205;
								}
							}
							else if (num7 != 61)
							{
								num7 = Unsafe.Add(ref reference3, num7);
								num7 <<= 6;
								elementOffset |= num7;
								if (elementOffset >= 0)
								{
									if (num3 <= length - 2)
									{
										Unsafe.Add(ref reference2, num3) = (byte)(elementOffset >> 16);
										Unsafe.Add(ref reference2, num3 + 1) = (byte)(elementOffset >> 8);
										num3 += 2;
										goto IL_01eb;
									}
									goto IL_0205;
								}
							}
							else if (elementOffset >= 0)
							{
								if (num3 <= length - 1)
								{
									Unsafe.Add(ref reference2, num3) = (byte)(elementOffset >> 16);
									num3++;
									goto IL_01eb;
								}
								goto IL_0205;
							}
						}
					}
					goto IL_022b;
					IL_01eb:
					num2 += 4;
					if (num == utf8.Length)
					{
						break;
					}
					goto IL_022b;
					IL_022b:
					bytesConsumed = num2;
					bytesWritten = num3;
					return OperationStatus.InvalidData;
					IL_0205:
					if (!(num != utf8.Length && isFinalBlock))
					{
						bytesConsumed = num2;
						bytesWritten = num3;
						return OperationStatus.DestinationTooSmall;
					}
					goto IL_022b;
				}
			}
			bytesConsumed = num2;
			bytesWritten = num3;
			return OperationStatus.Done;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetMaxDecodedFromUtf8Length(int length)
		{
			if (length < 0)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			return (length >> 2) * 3;
		}

		public static OperationStatus DecodeFromUtf8InPlace(Span<byte> buffer, out int bytesWritten)
		{
			int length = buffer.Length;
			int num = 0;
			int num2 = 0;
			if (length == (length >> 2) * 4)
			{
				if (length == 0)
				{
					goto IL_016d;
				}
				ref byte reference = ref MemoryMarshal.GetReference(buffer);
				ref sbyte reference2 = ref s_decodingMap[0];
				while (num < length - 4)
				{
					int num3 = Decode(ref Unsafe.Add(ref reference, num), ref reference2);
					if (num3 >= 0)
					{
						WriteThreeLowOrderBytes(ref Unsafe.Add(ref reference, num2), num3);
						num2 += 3;
						num += 4;
						continue;
					}
					goto IL_0172;
				}
				int elementOffset = Unsafe.Add(ref reference, length - 4);
				int elementOffset2 = Unsafe.Add(ref reference, length - 3);
				int num4 = Unsafe.Add(ref reference, length - 2);
				int num5 = Unsafe.Add(ref reference, length - 1);
				elementOffset = Unsafe.Add(ref reference2, elementOffset);
				elementOffset2 = Unsafe.Add(ref reference2, elementOffset2);
				elementOffset <<= 18;
				elementOffset2 <<= 12;
				elementOffset |= elementOffset2;
				if (num5 != 61)
				{
					num4 = Unsafe.Add(ref reference2, num4);
					num5 = Unsafe.Add(ref reference2, num5);
					num4 <<= 6;
					elementOffset |= num5;
					elementOffset |= num4;
					if (elementOffset >= 0)
					{
						WriteThreeLowOrderBytes(ref Unsafe.Add(ref reference, num2), elementOffset);
						num2 += 3;
						goto IL_016d;
					}
				}
				else if (num4 != 61)
				{
					num4 = Unsafe.Add(ref reference2, num4);
					num4 <<= 6;
					elementOffset |= num4;
					if (elementOffset >= 0)
					{
						Unsafe.Add(ref reference, num2) = (byte)(elementOffset >> 16);
						Unsafe.Add(ref reference, num2 + 1) = (byte)(elementOffset >> 8);
						num2 += 2;
						goto IL_016d;
					}
				}
				else if (elementOffset >= 0)
				{
					Unsafe.Add(ref reference, num2) = (byte)(elementOffset >> 16);
					num2++;
					goto IL_016d;
				}
			}
			goto IL_0172;
			IL_016d:
			bytesWritten = num2;
			return OperationStatus.Done;
			IL_0172:
			bytesWritten = num2;
			return OperationStatus.InvalidData;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int Decode(ref byte encodedBytes, ref sbyte decodingMap)
		{
			int elementOffset = encodedBytes;
			int elementOffset2 = Unsafe.Add(ref encodedBytes, 1);
			int elementOffset3 = Unsafe.Add(ref encodedBytes, 2);
			int elementOffset4 = Unsafe.Add(ref encodedBytes, 3);
			elementOffset = Unsafe.Add(ref decodingMap, elementOffset);
			elementOffset2 = Unsafe.Add(ref decodingMap, elementOffset2);
			elementOffset3 = Unsafe.Add(ref decodingMap, elementOffset3);
			elementOffset4 = Unsafe.Add(ref decodingMap, elementOffset4);
			elementOffset <<= 18;
			elementOffset2 <<= 12;
			elementOffset3 <<= 6;
			elementOffset |= elementOffset4;
			elementOffset2 |= elementOffset3;
			return elementOffset | elementOffset2;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteThreeLowOrderBytes(ref byte destination, int value)
		{
			destination = (byte)(value >> 16);
			Unsafe.Add(ref destination, 1) = (byte)(value >> 8);
			Unsafe.Add(ref destination, 2) = (byte)value;
		}

		public static OperationStatus EncodeToUtf8(ReadOnlySpan<byte> bytes, Span<byte> utf8, out int bytesConsumed, out int bytesWritten, bool isFinalBlock = true)
		{
			ref byte reference = ref MemoryMarshal.GetReference(bytes);
			ref byte reference2 = ref MemoryMarshal.GetReference(utf8);
			int length = bytes.Length;
			int length2 = utf8.Length;
			int num = 0;
			num = ((length > 1610612733 || length2 < GetMaxEncodedToUtf8Length(length)) ? ((length2 >> 2) * 3 - 2) : (length - 2));
			int i = 0;
			int num2 = 0;
			int num3 = 0;
			ref byte encodingMap = ref s_encodingMap[0];
			for (; i < num; i += 3)
			{
				num3 = Encode(ref Unsafe.Add(ref reference, i), ref encodingMap);
				Unsafe.WriteUnaligned(ref Unsafe.Add(ref reference2, num2), num3);
				num2 += 4;
			}
			if (num == length - 2)
			{
				if (isFinalBlock)
				{
					if (i == length - 1)
					{
						num3 = EncodeAndPadTwo(ref Unsafe.Add(ref reference, i), ref encodingMap);
						Unsafe.WriteUnaligned(ref Unsafe.Add(ref reference2, num2), num3);
						num2 += 4;
						i++;
					}
					else if (i == length - 2)
					{
						num3 = EncodeAndPadOne(ref Unsafe.Add(ref reference, i), ref encodingMap);
						Unsafe.WriteUnaligned(ref Unsafe.Add(ref reference2, num2), num3);
						num2 += 4;
						i += 2;
					}
					bytesConsumed = i;
					bytesWritten = num2;
					return OperationStatus.Done;
				}
				bytesConsumed = i;
				bytesWritten = num2;
				return OperationStatus.NeedMoreData;
			}
			bytesConsumed = i;
			bytesWritten = num2;
			return OperationStatus.DestinationTooSmall;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int GetMaxEncodedToUtf8Length(int length)
		{
			if ((uint)length > 1610612733u)
			{
				System.ThrowHelper.ThrowArgumentOutOfRangeException(System.ExceptionArgument.length);
			}
			return (length + 2) / 3 * 4;
		}

		public static OperationStatus EncodeToUtf8InPlace(Span<byte> buffer, int dataLength, out int bytesWritten)
		{
			int maxEncodedToUtf8Length = GetMaxEncodedToUtf8Length(dataLength);
			if (buffer.Length >= maxEncodedToUtf8Length)
			{
				int num = dataLength - dataLength / 3 * 3;
				int num2 = maxEncodedToUtf8Length - 4;
				int num3 = dataLength - num;
				int num4 = 0;
				ref byte encodingMap = ref s_encodingMap[0];
				ref byte reference = ref MemoryMarshal.GetReference(buffer);
				switch (num)
				{
				case 1:
					num4 = EncodeAndPadTwo(ref Unsafe.Add(ref reference, num3), ref encodingMap);
					Unsafe.WriteUnaligned(ref Unsafe.Add(ref reference, num2), num4);
					num2 -= 4;
					break;
				default:
					num4 = EncodeAndPadOne(ref Unsafe.Add(ref reference, num3), ref encodingMap);
					Unsafe.WriteUnaligned(ref Unsafe.Add(ref reference, num2), num4);
					num2 -= 4;
					break;
				case 0:
					break;
				}
				for (num3 -= 3; num3 >= 0; num3 -= 3)
				{
					num4 = Encode(ref Unsafe.Add(ref reference, num3), ref encodingMap);
					Unsafe.WriteUnaligned(ref Unsafe.Add(ref reference, num2), num4);
					num2 -= 4;
				}
				bytesWritten = maxEncodedToUtf8Length;
				return OperationStatus.Done;
			}
			bytesWritten = 0;
			return OperationStatus.DestinationTooSmall;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int Encode(ref byte threeBytes, ref byte encodingMap)
		{
			int num = (threeBytes << 16) | (Unsafe.Add(ref threeBytes, 1) << 8) | Unsafe.Add(ref threeBytes, 2);
			int num2 = Unsafe.Add(ref encodingMap, num >> 18);
			int num3 = Unsafe.Add(ref encodingMap, (num >> 12) & 0x3F);
			int num4 = Unsafe.Add(ref encodingMap, (num >> 6) & 0x3F);
			int num5 = Unsafe.Add(ref encodingMap, num & 0x3F);
			return num2 | (num3 << 8) | (num4 << 16) | (num5 << 24);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int EncodeAndPadOne(ref byte twoBytes, ref byte encodingMap)
		{
			int num = (twoBytes << 16) | (Unsafe.Add(ref twoBytes, 1) << 8);
			int num2 = Unsafe.Add(ref encodingMap, num >> 18);
			int num3 = Unsafe.Add(ref encodingMap, (num >> 12) & 0x3F);
			int num4 = Unsafe.Add(ref encodingMap, (num >> 6) & 0x3F);
			return num2 | (num3 << 8) | (num4 << 16) | 0x3D000000;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static int EncodeAndPadTwo(ref byte oneByte, ref byte encodingMap)
		{
			int num = oneByte << 8;
			int num2 = Unsafe.Add(ref encodingMap, num >> 10);
			int num3 = Unsafe.Add(ref encodingMap, (num >> 4) & 0x3F);
			return num2 | (num3 << 8) | 0x3D0000 | 0x3D000000;
		}
	}
	internal static class Utf8Constants
	{
		public const byte Colon = 58;

		public const byte Comma = 44;

		public const byte Minus = 45;

		public const byte Period = 46;

		public const byte Plus = 43;

		public const byte Slash = 47;

		public const byte Space = 32;

		public const byte Hyphen = 45;

		public const byte Separator = 44;

		public const int GroupSize = 3;

		public static readonly TimeSpan s_nullUtcOffset = TimeSpan.MinValue;

		public const int DateTimeMaxUtcOffsetHours = 14;

		public const int DateTimeNumFractionDigits = 7;

		public const int MaxDateTimeFraction = 9999999;

		public const ulong BillionMaxUIntValue = 4294967295000000000uL;

		public const uint Billion = 1000000000u;
	}
	internal static class FormattingHelpers
	{
		public enum HexCasing : uint
		{
			Uppercase = 0u,
			Lowercase = 8224u
		}

		internal const string HexTableLower = "0123456789abcdef";

		internal const string HexTableUpper = "0123456789ABCDEF";

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char GetSymbolOrDefault([In][<4c3ca4b8-ef70-4501-8c14-3851eaf0f71b>IsReadOnly] ref StandardFormat format, char defaultSymbol)
		{
			char c = format.Symbol;
			if (c == '\0' && format.Precision == 0)
			{
				c = defaultSymbol;
			}
			return c;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void FillWithAsciiZeros(Span<byte> buffer)
		{
			for (int i = 0; i < buffer.Length; i++)
			{
				buffer[i] = 48;
			}
		}

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

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDigits(ulong value, Span<byte> buffer)
		{
			for (int num = buffer.Length - 1; num >= 1; num--)
			{
				ulong num2 = 48 + value;
				value /= 10;
				buffer[num] = (byte)(num2 - value * 10);
			}
			buffer[0] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDigitsWithGroupSeparator(ulong value, Span<byte> buffer)
		{
			int num = 0;
			for (int num2 = buffer.Length - 1; num2 >= 1; num2--)
			{
				ulong num3 = 48 + value;
				value /= 10;
				buffer[num2] = (byte)(num3 - value * 10);
				if (num == 2)
				{
					buffer[--num2] = 44;
					num = 0;
				}
				else
				{
					num++;
				}
			}
			buffer[0] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDigits(uint value, Span<byte> buffer)
		{
			for (int num = buffer.Length - 1; num >= 1; num--)
			{
				uint num2 = 48 + value;
				value /= 10;
				buffer[num] = (byte)(num2 - value * 10);
			}
			buffer[0] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteFourDecimalDigits(uint value, Span<byte> buffer, int startingIndex = 0)
		{
			uint num = 48 + value;
			value /= 10;
			buffer[startingIndex + 3] = (byte)(num - value * 10);
			num = 48 + value;
			value /= 10;
			buffer[startingIndex + 2] = (byte)(num - value * 10);
			num = 48 + value;
			value /= 10;
			buffer[startingIndex + 1] = (byte)(num - value * 10);
			buffer[startingIndex] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteTwoDecimalDigits(uint value, Span<byte> buffer, int startingIndex = 0)
		{
			uint num = 48 + value;
			value /= 10;
			buffer[startingIndex + 1] = (byte)(num - value * 10);
			buffer[startingIndex] = (byte)(48 + value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ulong DivMod(ulong numerator, ulong denominator, out ulong modulo)
		{
			ulong num = numerator / denominator;
			modulo = numerator - num * denominator;
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static uint DivMod(uint numerator, uint denominator, out uint modulo)
		{
			uint num = numerator / denominator;
			modulo = numerator - num * denominator;
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountDecimalTrailingZeros(uint value, out uint valueWithoutTrailingZeros)
		{
			int num = 0;
			if (value != 0)
			{
				while (true)
				{
					uint modulo;
					uint num2 = DivMod(value, 10u, out modulo);
					if (modulo != 0)
					{
						break;
					}
					value = num2;
					num++;
				}
			}
			valueWithoutTrailingZeros = value;
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountDigits(ulong value)
		{
			int num = 1;
			uint num2;
			if (value >= 10000000)
			{
				if (value >= 100000000000000L)
				{
					num2 = (uint)(value / 100000000000000L);
					num += 14;
				}
				else
				{
					num2 = (uint)(value / 10000000);
					num += 7;
				}
			}
			else
			{
				num2 = (uint)value;
			}
			if (num2 >= 10)
			{
				num = ((num2 < 100) ? (num + 1) : ((num2 < 1000) ? (num + 2) : ((num2 < 10000) ? (num + 3) : ((num2 < 100000) ? (num + 4) : ((num2 >= 1000000) ? (num + 6) : (num + 5))))));
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountDigits(uint value)
		{
			int num = 1;
			if (value >= 100000)
			{
				value /= 100000;
				num += 5;
			}
			if (value >= 10)
			{
				num = ((value < 100) ? (num + 1) : ((value < 1000) ? (num + 2) : ((value >= 10000) ? (num + 4) : (num + 3))));
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int CountHexDigits(ulong value)
		{
			int num = 1;
			if (value > uint.MaxValue)
			{
				num += 8;
				value >>= 32;
			}
			if (value > 65535)
			{
				num += 4;
				value >>= 16;
			}
			if (value > 255)
			{
				num += 2;
				value >>= 8;
			}
			if (value > 15)
			{
				num++;
			}
			return num;
		}
	}
	internal static class Utf8Formatter
	{
		[StructLayout(LayoutKind.Explicit)]
		private struct DecomposedGuid
		{
			[FieldOffset(0)]
			public Guid Guid;

			[FieldOffset(0)]
			public byte Byte00;

			[FieldOffset(1)]
			public byte Byte01;

			[FieldOffset(2)]
			public byte Byte02;

			[FieldOffset(3)]
			public byte Byte03;

			[FieldOffset(4)]
			public byte Byte04;

			[FieldOffset(5)]
			public byte Byte05;

			[FieldOffset(6)]
			public byte Byte06;

			[FieldOffset(7)]
			public byte Byte07;

			[FieldOffset(8)]
			public byte Byte08;

			[FieldOffset(9)]
			public byte Byte09;

			[FieldOffset(10)]
			public byte Byte10;

			[FieldOffset(11)]
			public byte Byte11;

			[FieldOffset(12)]
			public byte Byte12;

			[FieldOffset(13)]
			public byte Byte13;

			[FieldOffset(14)]
			public byte Byte14;

			[FieldOffset(15)]
			public byte Byte15;
		}

		private const byte TimeMarker = 84;

		private const byte UtcMarker = 90;

		private const byte GMT1 = 71;

		private const byte GMT2 = 77;

		private const byte GMT3 = 84;

		private const byte GMT1Lowercase = 103;

		private const byte GMT2Lowercase = 109;

		private const byte GMT3Lowercase = 116;

		private static readonly uint[] DayAbbreviations = new uint[7] { 7238995u, 7237453u, 6649172u, 6579543u, 7694420u, 6910534u, 7627091u };

		private static readonly uint[] DayAbbreviationsLowercase = new uint[7] { 7239027u, 7237485u, 6649204u, 6579575u, 7694452u, 6910566u, 7627123u };

		private static readonly uint[] MonthAbbreviations = new uint[12]
		{
			7233866u, 6448454u, 7496013u, 7499841u, 7954765u, 7238986u, 7107914u, 6780225u, 7365971u, 7627599u,
			7761742u, 6513988u
		};

		private static readonly uint[] MonthAbbreviationsLowercase = new uint[12]
		{
			7233898u, 6448486u, 7496045u, 7499873u, 7954797u, 7239018u, 7107946u, 6780257u, 7366003u, 7627631u,
			7761774u, 6514020u
		};

		private const byte OpenBrace = 123;

		private const byte CloseBrace = 125;

		private const byte OpenParen = 40;

		private const byte CloseParen = 41;

		private const byte Dash = 45;

		public static bool TryFormat(bool value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			char symbolOrDefault = System.Buffers.Text.FormattingHelpers.GetSymbolOrDefault(ref format, 'G');
			if (value)
			{
				if (symbolOrDefault == 'G')
				{
					if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, 1416787301u))
					{
						goto IL_0033;
					}
				}
				else
				{
					if (symbolOrDefault != 'l')
					{
						goto IL_0083;
					}
					if (BinaryPrimitives.TryWriteUInt32BigEndian(destination, 1953658213u))
					{
						goto IL_0033;
					}
				}
			}
			else if (symbolOrDefault == 'G')
			{
				if (4u < (uint)destination.Length)
				{
					BinaryPrimitives.WriteUInt32BigEndian(destination, 1180789875u);
					goto IL_006e;
				}
			}
			else
			{
				if (symbolOrDefault != 'l')
				{
					goto IL_0083;
				}
				if (4u < (uint)destination.Length)
				{
					BinaryPrimitives.WriteUInt32BigEndian(destination, 1717660787u);
					goto IL_006e;
				}
			}
			bytesWritten = 0;
			return false;
			IL_0033:
			bytesWritten = 4;
			return true;
			IL_0083:
			return System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
			IL_006e:
			destination[4] = 101;
			bytesWritten = 5;
			return true;
		}

		public static bool TryFormat(DateTimeOffset value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			TimeSpan offset = System.Buffers.Text.Utf8Constants.s_nullUtcOffset;
			char c = format.Symbol;
			if (format.IsDefault)
			{
				c = 'G';
				offset = value.Offset;
			}
			return c switch
			{
				'R' => TryFormatDateTimeR(value.UtcDateTime, destination, out bytesWritten), 
				'l' => TryFormatDateTimeL(value.UtcDateTime, destination, out bytesWritten), 
				'O' => TryFormatDateTimeO(value.DateTime, value.Offset, destination, out bytesWritten), 
				'G' => TryFormatDateTimeG(value.DateTime, offset, destination, out bytesWritten), 
				_ => System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten), 
			};
		}

		public static bool TryFormat(DateTime value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return System.Buffers.Text.FormattingHelpers.GetSymbolOrDefault(ref format, 'G') switch
			{
				'R' => TryFormatDateTimeR(value, destination, out bytesWritten), 
				'l' => TryFormatDateTimeL(value, destination, out bytesWritten), 
				'O' => TryFormatDateTimeO(value, System.Buffers.Text.Utf8Constants.s_nullUtcOffset, destination, out bytesWritten), 
				'G' => TryFormatDateTimeG(value, System.Buffers.Text.Utf8Constants.s_nullUtcOffset, destination, out bytesWritten), 
				_ => System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten), 
			};
		}

		private static bool TryFormatDateTimeG(DateTime value, TimeSpan offset, Span<byte> destination, out int bytesWritten)
		{
			int num = 19;
			if (offset != System.Buffers.Text.Utf8Constants.s_nullUtcOffset)
			{
				num += 7;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			byte b = destination[18];
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Month, destination);
			destination[2] = 47;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, destination, 3);
			destination[5] = 47;
			System.Buffers.Text.FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, destination, 6);
			destination[10] = 32;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, destination, 11);
			destination[13] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, destination, 14);
			destination[16] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, destination, 17);
			if (offset != System.Buffers.Text.Utf8Constants.s_nullUtcOffset)
			{
				byte b2;
				if (offset < default(TimeSpan))
				{
					b2 = 45;
					offset = TimeSpan.FromTicks(-offset.Ticks);
				}
				else
				{
					b2 = 43;
				}
				System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Minutes, destination, 24);
				destination[23] = 58;
				System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Hours, destination, 21);
				destination[20] = b2;
				destination[19] = 32;
			}
			return true;
		}

		private static bool TryFormatDateTimeO(DateTime value, TimeSpan offset, Span<byte> destination, out int bytesWritten)
		{
			int num = 27;
			DateTimeKind dateTimeKind = DateTimeKind.Local;
			if (offset == System.Buffers.Text.Utf8Constants.s_nullUtcOffset)
			{
				dateTimeKind = value.Kind;
				switch (dateTimeKind)
				{
				case DateTimeKind.Local:
					offset = TimeZoneInfo.Local.GetUtcOffset(value);
					num += 6;
					break;
				case DateTimeKind.Utc:
					num++;
					break;
				}
			}
			else
			{
				num += 6;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			byte b = destination[26];
			System.Buffers.Text.FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, destination);
			destination[4] = 45;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Month, destination, 5);
			destination[7] = 45;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, destination, 8);
			destination[10] = 84;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, destination, 11);
			destination[13] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, destination, 14);
			destination[16] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, destination, 17);
			destination[19] = 46;
			System.Buffers.Text.FormattingHelpers.WriteDigits((uint)((ulong)value.Ticks % 10000000uL), destination.Slice(20, 7));
			switch (dateTimeKind)
			{
			case DateTimeKind.Local:
			{
				byte b2;
				if (offset < default(TimeSpan))
				{
					b2 = 45;
					offset = TimeSpan.FromTicks(-offset.Ticks);
				}
				else
				{
					b2 = 43;
				}
				System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Minutes, destination, 31);
				destination[30] = 58;
				System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)offset.Hours, destination, 28);
				destination[27] = b2;
				break;
			}
			case DateTimeKind.Utc:
				destination[27] = 90;
				break;
			}
			return true;
		}

		private static bool TryFormatDateTimeR(DateTime value, Span<byte> destination, out int bytesWritten)
		{
			if (28u >= (uint)destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			uint num = DayAbbreviations[(int)value.DayOfWeek];
			destination[0] = (byte)num;
			num >>= 8;
			destination[1] = (byte)num;
			num >>= 8;
			destination[2] = (byte)num;
			destination[3] = 44;
			destination[4] = 32;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, destination, 5);
			destination[7] = 32;
			uint num2 = MonthAbbreviations[value.Month - 1];
			destination[8] = (byte)num2;
			num2 >>= 8;
			destination[9] = (byte)num2;
			num2 >>= 8;
			destination[10] = (byte)num2;
			destination[11] = 32;
			System.Buffers.Text.FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, destination, 12);
			destination[16] = 32;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, destination, 17);
			destination[19] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, destination, 20);
			destination[22] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, destination, 23);
			destination[25] = 32;
			destination[26] = 71;
			destination[27] = 77;
			destination[28] = 84;
			bytesWritten = 29;
			return true;
		}

		private static bool TryFormatDateTimeL(DateTime value, Span<byte> destination, out int bytesWritten)
		{
			if (28u >= (uint)destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			uint num = DayAbbreviationsLowercase[(int)value.DayOfWeek];
			destination[0] = (byte)num;
			num >>= 8;
			destination[1] = (byte)num;
			num >>= 8;
			destination[2] = (byte)num;
			destination[3] = 44;
			destination[4] = 32;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Day, destination, 5);
			destination[7] = 32;
			uint num2 = MonthAbbreviationsLowercase[value.Month - 1];
			destination[8] = (byte)num2;
			num2 >>= 8;
			destination[9] = (byte)num2;
			num2 >>= 8;
			destination[10] = (byte)num2;
			destination[11] = 32;
			System.Buffers.Text.FormattingHelpers.WriteFourDecimalDigits((uint)value.Year, destination, 12);
			destination[16] = 32;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Hour, destination, 17);
			destination[19] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Minute, destination, 20);
			destination[22] = 58;
			System.Buffers.Text.FormattingHelpers.WriteTwoDecimalDigits((uint)value.Second, destination, 23);
			destination[25] = 32;
			destination[26] = 103;
			destination[27] = 109;
			destination[28] = 116;
			bytesWritten = 29;
			return true;
		}

		public static bool TryFormat(decimal value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			if (format.IsDefault)
			{
				format = 'G';
			}
			switch (format.Symbol)
			{
			case 'G':
			case 'g':
			{
				if (format.Precision != byte.MaxValue)
				{
					throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_GWithPrecisionNotSupported);
				}
				NumberBuffer number3 = default(NumberBuffer);
				System.Number.DecimalToNumber(value, ref number3);
				if (number3.Digits[0] == 0)
				{
					number3.IsNegative = false;
				}
				return TryFormatDecimalG(ref number3, destination, out bytesWritten);
			}
			case 'F':
			case 'f':
			{
				NumberBuffer number2 = default(NumberBuffer);
				System.Number.DecimalToNumber(value, ref number2);
				byte b2 = (byte)((format.Precision == byte.MaxValue) ? 2 : format.Precision);
				System.Number.RoundNumber(ref number2, number2.Scale + b2);
				return TryFormatDecimalF(ref number2, destination, out bytesWritten, b2);
			}
			case 'E':
			case 'e':
			{
				NumberBuffer number = default(NumberBuffer);
				System.Number.DecimalToNumber(value, ref number);
				byte b = (byte)((format.Precision == byte.MaxValue) ? 6 : format.Precision);
				System.Number.RoundNumber(ref number, b + 1);
				return TryFormatDecimalE(ref number, destination, out bytesWritten, b, (byte)format.Symbol);
			}
			default:
				return System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
			}
		}

		private static bool TryFormatDecimalE(ref NumberBuffer number, Span<byte> destination, out int bytesWritten, byte precision, byte exponentSymbol)
		{
			int scale = number.Scale;
			ReadOnlySpan<byte> readOnlySpan = number.Digits;
			int num = (number.IsNegative ? 1 : 0) + 1 + ((precision != 0) ? (precision + 1) : 0) + 2 + 3;
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			int num2 = 0;
			int num3 = 0;
			if (number.IsNegative)
			{
				destination[num2++] = 45;
			}
			byte b = readOnlySpan[num3];
			int num4;
			if (b == 0)
			{
				destination[num2++] = 48;
				num4 = 0;
			}
			else
			{
				destination[num2++] = b;
				num3++;
				num4 = scale - 1;
			}
			if (precision > 0)
			{
				destination[num2++] = 46;
				for (int i = 0; i < precision; i++)
				{
					byte b2 = readOnlySpan[num3];
					if (b2 == 0)
					{
						while (i++ < precision)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b2;
					num3++;
				}
			}
			destination[num2++] = exponentSymbol;
			if (num4 >= 0)
			{
				destination[num2++] = 43;
			}
			else
			{
				destination[num2++] = 45;
				num4 = -num4;
			}
			destination[num2++] = 48;
			destination[num2++] = (byte)(num4 / 10 + 48);
			destination[num2++] = (byte)(num4 % 10 + 48);
			bytesWritten = num;
			return true;
		}

		private static bool TryFormatDecimalF(ref NumberBuffer number, Span<byte> destination, out int bytesWritten, byte precision)
		{
			int scale = number.Scale;
			ReadOnlySpan<byte> readOnlySpan = number.Digits;
			int num = (number.IsNegative ? 1 : 0) + ((scale <= 0) ? 1 : scale) + ((precision != 0) ? (precision + 1) : 0);
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			int i = 0;
			int num2 = 0;
			if (number.IsNegative)
			{
				destination[num2++] = 45;
			}
			if (scale <= 0)
			{
				destination[num2++] = 48;
			}
			else
			{
				for (; i < scale; i++)
				{
					byte b = readOnlySpan[i];
					if (b == 0)
					{
						int num3 = scale - i;
						for (int j = 0; j < num3; j++)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b;
				}
			}
			if (precision > 0)
			{
				destination[num2++] = 46;
				int k = 0;
				if (scale < 0)
				{
					int num4 = Math.Min(precision, -scale);
					for (int l = 0; l < num4; l++)
					{
						destination[num2++] = 48;
					}
					k += num4;
				}
				for (; k < precision; k++)
				{
					byte b2 = readOnlySpan[i];
					if (b2 == 0)
					{
						while (k++ < precision)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b2;
					i++;
				}
			}
			bytesWritten = num;
			return true;
		}

		private static bool TryFormatDecimalG(ref NumberBuffer number, Span<byte> destination, out int bytesWritten)
		{
			int scale = number.Scale;
			ReadOnlySpan<byte> readOnlySpan = number.Digits;
			int numDigits = number.NumDigits;
			bool flag = scale < numDigits;
			int num;
			if (flag)
			{
				num = numDigits + 1;
				if (scale <= 0)
				{
					num += 1 + -scale;
				}
			}
			else
			{
				num = ((scale <= 0) ? 1 : scale);
			}
			if (number.IsNegative)
			{
				num++;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			int i = 0;
			int num2 = 0;
			if (number.IsNegative)
			{
				destination[num2++] = 45;
			}
			if (scale <= 0)
			{
				destination[num2++] = 48;
			}
			else
			{
				for (; i < scale; i++)
				{
					byte b = readOnlySpan[i];
					if (b == 0)
					{
						int num3 = scale - i;
						for (int j = 0; j < num3; j++)
						{
							destination[num2++] = 48;
						}
						break;
					}
					destination[num2++] = b;
				}
			}
			if (flag)
			{
				destination[num2++] = 46;
				if (scale < 0)
				{
					int num4 = -scale;
					for (int k = 0; k < num4; k++)
					{
						destination[num2++] = 48;
					}
				}
				byte b2;
				while ((b2 = readOnlySpan[i++]) != 0)
				{
					destination[num2++] = b2;
				}
			}
			bytesWritten = num;
			return true;
		}

		public static bool TryFormat(double value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatFloatingPoint(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(float value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatFloatingPoint(value, destination, out bytesWritten, format);
		}

		private static bool TryFormatFloatingPoint<T>(T value, Span<byte> destination, out int bytesWritten, StandardFormat format) where T : IFormattable
		{
			if (format.IsDefault)
			{
				format = 'G';
			}
			switch (format.Symbol)
			{
			case 'G':
			case 'g':
				if (format.Precision != byte.MaxValue)
				{
					throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_GWithPrecisionNotSupported);
				}
				break;
			default:
				return System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
			case 'E':
			case 'F':
			case 'e':
			case 'f':
				break;
			}
			string text = format.ToString();
			string text2 = value.ToString(text, CultureInfo.InvariantCulture);
			int length = text2.Length;
			if (length > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			for (int i = 0; i < length; i++)
			{
				destination[i] = (byte)text2[i];
			}
			bytesWritten = length;
			return true;
		}

		public static bool TryFormat(Guid value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			int num;
			switch (System.Buffers.Text.FormattingHelpers.GetSymbolOrDefault(ref format, 'D'))
			{
			case 'D':
				num = -2147483612;
				break;
			case 'B':
				num = -2139260122;
				break;
			case 'P':
				num = -2144786394;
				break;
			case 'N':
				num = 32;
				break;
			default:
				return System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
			}
			if ((byte)num > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = (byte)num;
			num >>= 8;
			if ((byte)num != 0)
			{
				destination[0] = (byte)num;
				destination = destination.Slice(1);
			}
			num >>= 8;
			DecomposedGuid decomposedGuid = default(DecomposedGuid);
			decomposedGuid.Guid = value;
			byte b = destination[8];
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte03, destination, 0, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte02, destination, 2, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte01, destination, 4, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte00, destination, 6, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			if (num < 0)
			{
				destination[8] = 45;
				destination = destination.Slice(9);
			}
			else
			{
				destination = destination.Slice(8);
			}
			byte b2 = destination[4];
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte05, destination, 0, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte04, destination, 2, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			if (num < 0)
			{
				destination[4] = 45;
				destination = destination.Slice(5);
			}
			else
			{
				destination = destination.Slice(4);
			}
			byte b3 = destination[4];
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte07, destination, 0, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte06, destination, 2, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			if (num < 0)
			{
				destination[4] = 45;
				destination = destination.Slice(5);
			}
			else
			{
				destination = destination.Slice(4);
			}
			byte b4 = destination[4];
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte08, destination, 0, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte09, destination, 2, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			if (num < 0)
			{
				destination[4] = 45;
				destination = destination.Slice(5);
			}
			else
			{
				destination = destination.Slice(4);
			}
			byte b5 = destination[11];
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte10, destination, 0, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte11, destination, 2, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte12, destination, 4, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte13, destination, 6, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte14, destination, 8, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			System.Buffers.Text.FormattingHelpers.WriteHexByte(decomposedGuid.Byte15, destination, 10, System.Buffers.Text.FormattingHelpers.HexCasing.Lowercase);
			if ((byte)num != 0)
			{
				destination[12] = (byte)num;
			}
			return true;
		}

		public static bool TryFormat(byte value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(sbyte value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, 255uL, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(ushort value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(short value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, 65535uL, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(uint value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(int value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, 4294967295uL, destination, out bytesWritten, format);
		}

		[CLSCompliant(false)]
		public static bool TryFormat(ulong value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatUInt64(value, destination, out bytesWritten, format);
		}

		public static bool TryFormat(long value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			return TryFormatInt64(value, ulong.MaxValue, destination, out bytesWritten, format);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64(long value, ulong mask, Span<byte> destination, out int bytesWritten, StandardFormat format)
		{
			if (format.IsDefault)
			{
				return TryFormatInt64Default(value, destination, out bytesWritten);
			}
			switch (format.Symbol)
			{
			case 'G':
			case 'g':
				if (format.HasPrecision)
				{
					throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_GWithPrecisionNotSupported);
				}
				return TryFormatInt64D(value, format.Precision, destination, out bytesWritten);
			case 'D':
			case 'd':
				return TryFormatInt64D(value, format.Precision, destination, out bytesWritten);
			case 'N':
			case 'n':
				return TryFormatInt64N(value, format.Precision, destination, out bytesWritten);
			case 'x':
				return TryFormatUInt64X((ulong)value & mask, format.Precision, useLower: true, destination, out bytesWritten);
			case 'X':
				return TryFormatUInt64X((ulong)value & mask, format.Precision, useLower: false, destination, out bytesWritten);
			default:
				return System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64D(long value, byte precision, Span<byte> destination, out int bytesWritten)
		{
			bool insertNegationSign = false;
			if (value < 0)
			{
				insertNegationSign = true;
				value = -value;
			}
			return TryFormatUInt64D((ulong)value, precision, destination, insertNegationSign, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64Default(long value, Span<byte> destination, out int bytesWritten)
		{
			if ((ulong)value < 10uL)
			{
				return TryFormatUInt32SingleDigit((uint)value, destination, out bytesWritten);
			}
			if (IntPtr.Size == 8)
			{
				return TryFormatInt64MultipleDigits(value, destination, out bytesWritten);
			}
			if (value <= int.MaxValue && value >= int.MinValue)
			{
				return TryFormatInt32MultipleDigits((int)value, destination, out bytesWritten);
			}
			if (value <= 4294967295000000000L && value >= -4294967295000000000L)
			{
				if (value >= 0)
				{
					return TryFormatUInt64LessThanBillionMaxUInt((ulong)value, destination, out bytesWritten);
				}
				return TryFormatInt64MoreThanNegativeBillionMaxUInt(-value, destination, out bytesWritten);
			}
			if (value >= 0)
			{
				return TryFormatUInt64MoreThanBillionMaxUInt((ulong)value, destination, out bytesWritten);
			}
			return TryFormatInt64LessThanNegativeBillionMaxUInt(-value, destination, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt32Default(int value, Span<byte> destination, out int bytesWritten)
		{
			if ((uint)value < 10u)
			{
				return TryFormatUInt32SingleDigit((uint)value, destination, out bytesWritten);
			}
			return TryFormatInt32MultipleDigits(value, destination, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt32MultipleDigits(int value, Span<byte> destination, out int bytesWritten)
		{
			if (value < 0)
			{
				value = -value;
				int num = System.Buffers.Text.FormattingHelpers.CountDigits((uint)value);
				if (num >= destination.Length)
				{
					bytesWritten = 0;
					return false;
				}
				destination[0] = 45;
				bytesWritten = num + 1;
				System.Buffers.Text.FormattingHelpers.WriteDigits((uint)value, destination.Slice(1, num));
				return true;
			}
			return TryFormatUInt32MultipleDigits((uint)value, destination, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64MultipleDigits(long value, Span<byte> destination, out int bytesWritten)
		{
			if (value < 0)
			{
				value = -value;
				int num = System.Buffers.Text.FormattingHelpers.CountDigits((ulong)value);
				if (num >= destination.Length)
				{
					bytesWritten = 0;
					return false;
				}
				destination[0] = 45;
				bytesWritten = num + 1;
				System.Buffers.Text.FormattingHelpers.WriteDigits((ulong)value, destination.Slice(1, num));
				return true;
			}
			return TryFormatUInt64MultipleDigits((ulong)value, destination, out bytesWritten);
		}

		private static bool TryFormatInt64MoreThanNegativeBillionMaxUInt(long value, Span<byte> destination, out int bytesWritten)
		{
			uint num = (uint)(value / 1000000000);
			uint value2 = (uint)(value - num * 1000000000);
			int num2 = System.Buffers.Text.FormattingHelpers.CountDigits(num);
			int num3 = num2 + 9;
			if (num3 >= destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			destination[0] = 45;
			bytesWritten = num3 + 1;
			System.Buffers.Text.FormattingHelpers.WriteDigits(num, destination.Slice(1, num2));
			System.Buffers.Text.FormattingHelpers.WriteDigits(value2, destination.Slice(num2 + 1, 9));
			return true;
		}

		private static bool TryFormatInt64LessThanNegativeBillionMaxUInt(long value, Span<byte> destination, out int bytesWritten)
		{
			ulong num = (ulong)value / 1000000000uL;
			uint value2 = (uint)((ulong)value - num * 1000000000);
			uint num2 = (uint)(num / 1000000000);
			uint value3 = (uint)(num - num2 * 1000000000);
			int num3 = System.Buffers.Text.FormattingHelpers.CountDigits(num2);
			int num4 = num3 + 18;
			if (num4 >= destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			destination[0] = 45;
			bytesWritten = num4 + 1;
			System.Buffers.Text.FormattingHelpers.WriteDigits(num2, destination.Slice(1, num3));
			System.Buffers.Text.FormattingHelpers.WriteDigits(value3, destination.Slice(num3 + 1, 9));
			System.Buffers.Text.FormattingHelpers.WriteDigits(value2, destination.Slice(num3 + 1 + 9, 9));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatInt64N(long value, byte precision, Span<byte> destination, out int bytesWritten)
		{
			bool insertNegationSign = false;
			if (value < 0)
			{
				insertNegationSign = true;
				value = -value;
			}
			return TryFormatUInt64N((ulong)value, precision, destination, insertNegationSign, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt64(ulong value, Span<byte> destination, out int bytesWritten, StandardFormat format)
		{
			if (format.IsDefault)
			{
				return TryFormatUInt64Default(value, destination, out bytesWritten);
			}
			switch (format.Symbol)
			{
			case 'G':
			case 'g':
				if (format.HasPrecision)
				{
					throw new NotSupportedException(<2cdd3d99-010c-4688-b500-482730d0e75a>SR.Argument_GWithPrecisionNotSupported);
				}
				return TryFormatUInt64D(value, format.Precision, destination, insertNegationSign: false, out bytesWritten);
			case 'D':
			case 'd':
				return TryFormatUInt64D(value, format.Precision, destination, insertNegationSign: false, out bytesWritten);
			case 'N':
			case 'n':
				return TryFormatUInt64N(value, format.Precision, destination, insertNegationSign: false, out bytesWritten);
			case 'x':
				return TryFormatUInt64X(value, format.Precision, useLower: true, destination, out bytesWritten);
			case 'X':
				return TryFormatUInt64X(value, format.Precision, useLower: false, destination, out bytesWritten);
			default:
				return System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
			}
		}

		private static bool TryFormatUInt64D(ulong value, byte precision, Span<byte> destination, bool insertNegationSign, out int bytesWritten)
		{
			int num = System.Buffers.Text.FormattingHelpers.CountDigits(value);
			int num2 = ((precision != byte.MaxValue) ? precision : 0) - num;
			if (num2 < 0)
			{
				num2 = 0;
			}
			int num3 = num + num2;
			if (insertNegationSign)
			{
				num3++;
			}
			if (num3 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num3;
			if (insertNegationSign)
			{
				destination[0] = 45;
				destination = destination.Slice(1);
			}
			if (num2 > 0)
			{
				System.Buffers.Text.FormattingHelpers.FillWithAsciiZeros(destination.Slice(0, num2));
			}
			System.Buffers.Text.FormattingHelpers.WriteDigits(value, destination.Slice(num2, num));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt64Default(ulong value, Span<byte> destination, out int bytesWritten)
		{
			if (value < 10)
			{
				return TryFormatUInt32SingleDigit((uint)value, destination, out bytesWritten);
			}
			if (IntPtr.Size == 8)
			{
				return TryFormatUInt64MultipleDigits(value, destination, out bytesWritten);
			}
			if (value <= uint.MaxValue)
			{
				return TryFormatUInt32MultipleDigits((uint)value, destination, out bytesWritten);
			}
			if (value <= 4294967295000000000L)
			{
				return TryFormatUInt64LessThanBillionMaxUInt(value, destination, out bytesWritten);
			}
			return TryFormatUInt64MoreThanBillionMaxUInt(value, destination, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt32Default(uint value, Span<byte> destination, out int bytesWritten)
		{
			if (value < 10)
			{
				return TryFormatUInt32SingleDigit(value, destination, out bytesWritten);
			}
			return TryFormatUInt32MultipleDigits(value, destination, out bytesWritten);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt32SingleDigit(uint value, Span<byte> destination, out int bytesWritten)
		{
			if (destination.Length == 0)
			{
				bytesWritten = 0;
				return false;
			}
			destination[0] = (byte)(48 + value);
			bytesWritten = 1;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt32MultipleDigits(uint value, Span<byte> destination, out int bytesWritten)
		{
			int num = System.Buffers.Text.FormattingHelpers.CountDigits(value);
			if (num > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			System.Buffers.Text.FormattingHelpers.WriteDigits(value, destination.Slice(0, num));
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt64SingleDigit(ulong value, Span<byte> destination, out int bytesWritten)
		{
			if (destination.Length == 0)
			{
				bytesWritten = 0;
				return false;
			}
			destination[0] = (byte)(48 + value);
			bytesWritten = 1;
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static bool TryFormatUInt64MultipleDigits(ulong value, Span<byte> destination, out int bytesWritten)
		{
			int num = System.Buffers.Text.FormattingHelpers.CountDigits(value);
			if (num > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			System.Buffers.Text.FormattingHelpers.WriteDigits(value, destination.Slice(0, num));
			return true;
		}

		private static bool TryFormatUInt64LessThanBillionMaxUInt(ulong value, Span<byte> destination, out int bytesWritten)
		{
			uint num = (uint)(value / 1000000000);
			uint value2 = (uint)(value - num * 1000000000);
			int num2 = System.Buffers.Text.FormattingHelpers.CountDigits(num);
			int num3 = num2 + 9;
			if (num3 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num3;
			System.Buffers.Text.FormattingHelpers.WriteDigits(num, destination.Slice(0, num2));
			System.Buffers.Text.FormattingHelpers.WriteDigits(value2, destination.Slice(num2, 9));
			return true;
		}

		private static bool TryFormatUInt64MoreThanBillionMaxUInt(ulong value, Span<byte> destination, out int bytesWritten)
		{
			ulong num = value / 1000000000;
			uint value2 = (uint)(value - num * 1000000000);
			uint num2 = (uint)(num / 1000000000);
			uint value3 = (uint)(num - num2 * 1000000000);
			int num3 = System.Buffers.Text.FormattingHelpers.CountDigits(num2);
			int num4 = num3 + 18;
			if (num4 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num4;
			System.Buffers.Text.FormattingHelpers.WriteDigits(num2, destination.Slice(0, num3));
			System.Buffers.Text.FormattingHelpers.WriteDigits(value3, destination.Slice(num3, 9));
			System.Buffers.Text.FormattingHelpers.WriteDigits(value2, destination.Slice(num3 + 9, 9));
			return true;
		}

		private static bool TryFormatUInt64N(ulong value, byte precision, Span<byte> destination, bool insertNegationSign, out int bytesWritten)
		{
			int num = System.Buffers.Text.FormattingHelpers.CountDigits(value);
			int num2 = (num - 1) / 3;
			int num3 = ((precision == byte.MaxValue) ? 2 : precision);
			int num4 = num + num2;
			if (num3 > 0)
			{
				num4 += num3 + 1;
			}
			if (insertNegationSign)
			{
				num4++;
			}
			if (num4 > destination.Length)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num4;
			if (insertNegationSign)
			{
				destination[0] = 45;
				destination = destination.Slice(1);
			}
			System.Buffers.Text.FormattingHelpers.WriteDigitsWithGroupSeparator(value, destination.Slice(0, num + num2));
			if (num3 > 0)
			{
				destination[num + num2] = 46;
				System.Buffers.Text.FormattingHelpers.FillWithAsciiZeros(destination.Slice(num + num2 + 1, num3));
			}
			return true;
		}

		private static bool TryFormatUInt64X(ulong value, byte precision, bool useLower, Span<byte> destination, out int bytesWritten)
		{
			int num = System.Buffers.Text.FormattingHelpers.CountHexDigits(value);
			int num2 = ((precision == byte.MaxValue) ? num : Math.Max(precision, num));
			if (destination.Length < num2)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num2;
			string text = (useLower ? "0123456789abcdef" : "0123456789ABCDEF");
			while ((uint)(--num2) < (uint)destination.Length)
			{
				destination[num2] = (byte)text[(int)value & 0xF];
				value >>= 4;
			}
			return true;
		}

		public static bool TryFormat(TimeSpan value, Span<byte> destination, out int bytesWritten, StandardFormat format = default(StandardFormat))
		{
			char c = System.Buffers.Text.FormattingHelpers.GetSymbolOrDefault(ref format, 'c');
			switch (c)
			{
			case 'T':
			case 't':
				c = 'c';
				break;
			default:
				return System.ThrowHelper.TryFormatThrowFormatException(out bytesWritten);
			case 'G':
			case 'c':
			case 'g':
				break;
			}
			int num = 8;
			long ticks = value.Ticks;
			uint valueWithoutTrailingZeros;
			ulong num2;
			if (ticks < 0)
			{
				ticks = -ticks;
				if (ticks < 0)
				{
					valueWithoutTrailingZeros = 4775808u;
					num2 = 922337203685uL;
					goto IL_0082;
				}
			}
			num2 = System.Buffers.Text.FormattingHelpers.DivMod((ulong)Math.Abs(value.Ticks), 10000000uL, out var modulo);
			valueWithoutTrailingZeros = (uint)modulo;
			goto IL_0082;
			IL_0082:
			int num3 = 0;
			switch (c)
			{
			case 'c':
				if (valueWithoutTrailingZeros != 0)
				{
					num3 = 7;
				}
				break;
			case 'G':
				num3 = 7;
				break;
			default:
				if (valueWithoutTrailingZeros != 0)
				{
					num3 = 7 - System.Buffers.Text.FormattingHelpers.CountDecimalTrailingZeros(valueWithoutTrailingZeros, out valueWithoutTrailingZeros);
				}
				break;
			}
			if (num3 != 0)
			{
				num += num3 + 1;
			}
			ulong num4 = 0uL;
			ulong modulo2 = 0uL;
			if (num2 != 0)
			{
				num4 = System.Buffers.Text.FormattingHelpers.DivMod(num2, 60uL, out modulo2);
			}
			ulong num5 = 0uL;
			ulong modulo3 = 0uL;
			if (num4 != 0)
			{
				num5 = System.Buffers.Text.FormattingHelpers.DivMod(num4, 60uL, out modulo3);
			}
			uint num6 = 0u;
			uint modulo4 = 0u;
			if (num5 != 0)
			{
				num6 = System.Buffers.Text.FormattingHelpers.DivMod((uint)num5, 24u, out modulo4);
			}
			int num7 = 2;
			if (modulo4 < 10 && c == 'g')
			{
				num7--;
				num--;
			}
			int num8 = 0;
			if (num6 == 0)
			{
				if (c == 'G')
				{
					num += 2;
					num8 = 1;
				}
			}
			else
			{
				num8 = System.Buffers.Text.FormattingHelpers.CountDigits(num6);
				num += num8 + 1;
			}
			if (value.Ticks < 0)
			{
				num++;
			}
			if (destination.Length < num)
			{
				bytesWritten = 0;
				return false;
			}
			bytesWritten = num;
			int num9 = 0;
			if (value.Ticks < 0)
			{
				destination[num9++] = 45;
			}
			if (num8 > 0)
			{
				System.Buffers.Text.FormattingHelpers.WriteDigits(num6, destination.Slice(num9, num8));
				num9 += num8;
				destination[num9++] = (byte)((c == 'c') ? 46 : 58);
			}
			System.Buffers.Text.FormattingHelpers.WriteDigits(modulo4, destination.Slice(num9, num7));
			num9 += num7;
			destination[num9++] = 58;
			System.Buffers.Text.FormattingHelpers.WriteDigits((uint)modulo3, destination.Slice(num9, 2));
			num9 += 2;
			destination[num9++] = 58;
			System.Buffers.Text.FormattingHelpers.WriteDigits((uint)modulo2, destination.Slice(num9, 2));
			num9 += 2;
			if (num3 > 0)
			{
				destination[num9++] = 46;
				System.Buffers.Text.FormattingHelpers.WriteDigits(valueWithoutTrailingZeros, destination.Slice(num9, num3));
				num9 += num3;
			}
			return true;
		}
	}
	internal static class ParserHelpers
	{
		public const int ByteOverflowLength = 3;

		public const int ByteOverflowLengthHex = 2;

		public const int UInt16OverflowLength = 5;

		public const int UInt16OverflowLengthHex = 4;

		public const int UInt32OverflowLength = 10;

		public const int UInt32OverflowLengthHex = 8;

		public const int UInt64OverflowLength = 20;

		public const int UInt64OverflowLengthHex = 16;

		public const int SByteOverflowLength = 3;

		public const int SByteOverflowLengthHex = 2;

		public const int Int16OverflowLength = 5;

		public const int Int16OverflowLengthHex = 4;

		public const int Int32OverflowLength = 10;

		public const int Int32OverflowLengthHex = 8;

		public const int Int64OverflowLength = 19;

		public const int Int64OverflowLengthHex = 16;

		public static readonly byte[] s_hexLookup = new byte[256]
		{
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 0, 1,
			2, 3, 4, 5, 6, 7, 8, 9, 255, 255,
			255, 255, 255, 255, 255, 10, 11, 12, 13, 14,
			15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 10, 11, 12,
			13, 14, 15, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255
		};

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsDigit(int i)
		{
			return (uint)(i - 48) <= 9u;
		}
	}
	internal static class Utf8Parser
	{
		[Flags]
		private enum ParseNumberOptions
		{
			AllowExponent = 1
		}

		private enum ComponentParseResult : byte
		{
			NoMoreData,
			Colon,
			Period,
			ParseFailure
		}

		private struct TimeSpanSplitter
		{
			public uint V1;

			public uint V2;

			public uint V3;

			public uint V4;

			public uint V5;

			public bool IsNegative;

			public uint Separators;

			public bool TrySplitTimeSpan(ReadOnlySpan<byte> source, bool periodUsedToSeparateDay, out int bytesConsumed)
			{
				int i = 0;
				byte b = 0;
				for (; i != source.Length; i++)
				{
					b = source[i];
					if (b != 32 && b != 9)
					{
						break;
					}
				}
				if (i == source.Length)
				{
					bytesConsumed = 0;
					return false;
				}
				if (b == 45)
				{
					IsNegative = true;
					i++;
					if (i == source.Length)
					{
						bytesConsumed = 0;
						return false;
					}
				}
				if (!TryParseUInt32D(source.Slice(i), out V1, out var bytesConsumed2))
				{
					bytesConsumed = 0;
					return false;
				}
				i += bytesConsumed2;
				ComponentParseResult componentParseResult = ParseComponent(source, periodUsedToSeparateDay, ref i, out V2);
				switch (componentParseResult)
				{
				case ComponentParseResult.ParseFailure:
					bytesConsumed = 0;
					return false;
				case ComponentParseResult.NoMoreData:
					bytesConsumed = i;
					return true;
				default:
					Separators |= (uint)componentParseResult << 24;
					componentParseResult = ParseComponent(source, neverParseAsFraction: false, ref i, out V3);
					switch (componentParseResult)
					{
					case ComponentParseResult.ParseFailure:
						bytesConsumed = 0;
						return false;
					case ComponentParseResult.NoMoreData:
						bytesConsumed = i;
						return true;
					default:
						Separators |= (uint)componentParseResult << 16;
						componentParseResult = ParseComponent(source, neverParseAsFraction: false, ref i, out V4);
						switch (componentParseResult)
						{
						case ComponentParseResult.ParseFailure:
							bytesConsumed = 0;
							return false;
						case ComponentParseResult.NoMoreData:
							bytesConsumed = i;
							return true;
						default:
							Separators |= (uint)componentParseResult << 8;
							componentParseResult = ParseComponent(source, neverParseAsFraction: false, ref i, out V5);
							switch (componentParseResult)
							{
							case ComponentParseResult.ParseFailure:
								bytesConsumed = 0;
								return false;
							case ComponentParseResult.NoMoreData:
								bytesConsumed = i;
								return true;
							default:
								Separators |= (uint)componentParseResult;
								if (i != source.Length && (source[i] == 46 || source[i] == 58))
								{
									bytesConsumed = 0;
									return false;
								}
								bytesConsumed = i;
								return true;
							}
						}
					}
				}
			}

			private static ComponentParseResult ParseComponent(ReadOnlySpan<byte> source, bool neverParseAsFraction, ref int srcIndex, out uint value)
			{
				if (srcIndex == source.Length)
				{
					value = 0u;
					return ComponentParseResult.NoMoreData;
				}
				byte b = source[srcIndex];
				if (b == 58 || (b == 46 && neverParseAsFraction))
				{
					srcIndex++;
					if (!TryParseUInt32D(source.Slice(srcIndex), out value, out var bytesConsumed))
					{
						value = 0u;
						return ComponentParseResult.ParseFailure;
					}
					srcIndex += bytesConsumed;
					if (b != 58)
					{
						return ComponentParseResult.Period;
					}
					return ComponentParseResult.Colon;
				}
				if (b == 46)
				{
					srcIndex++;
					if (!TryParseTimeSpanFraction(source.Slice(srcIndex), out value, out var bytesConsumed2))
					{
						value = 0u;
						return ComponentParseResult.ParseFailure;
					}
					srcIndex += bytesConsumed2;
					return ComponentParseResult.Period;
				}
				value = 0u;
				return ComponentParseResult.NoMoreData;
			}
		}

		private const uint FlipCase = 32u;

		private const uint NoFlipCase = 0u;

		private static readonly int[] s_daysToMonth365 = new int[13]
		{
			0, 31, 59, 90, 120, 151, 181, 212, 243, 273,
			304, 334, 365
		};

		private static readonly int[] s_daysToMonth366 = new int[13]
		{
			0, 31, 60, 91, 121, 152, 182, 213, 244, 274,
			305, 335, 366
		};

		public static bool TryParse(ReadOnlySpan<byte> source, out bool value, out int bytesConsumed, char standardFormat = '\0')
		{
			if (standardFormat != 0 && standardFormat != 'G' && standardFormat != 'l')
			{
				return System.ThrowHelper.TryParseThrowFormatException<bool>(out value, out bytesConsumed);
			}
			if (source.Length >= 4)
			{
				if ((source[0] == 84 || source[0] == 116) && (source[1] == 82 || source[1] == 114) && (source[2] == 85 || source[2] == 117) && (source[3] == 69 || source[3] == 101))
				{
					bytesConsumed = 4;
					value = true;
					return true;
				}
				if (source.Length >= 5 && (source[0] == 70 || source[0] == 102) && (source[1] == 65 || source[1] == 97) && (source[2] == 76 || source[2] == 108) && (source[3] == 83 || source[3] == 115) && (source[4] == 69 || source[4] == 101))
				{
					bytesConsumed = 5;
					value = false;
					return true;
				}
			}
			bytesConsumed = 0;
			value = false;
			return false;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out DateTime value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case 'R':
			{
				if (!TryParseDateTimeOffsetR(source, 0u, out var dateTimeOffset, out bytesConsumed))
				{
					value = default(DateTime);
					return false;
				}
				value = dateTimeOffset.DateTime;
				return true;
			}
			case 'l':
			{
				if (!TryParseDateTimeOffsetR(source, 32u, out var dateTimeOffset2, out bytesConsumed))
				{
					value = default(DateTime);
					return false;
				}
				value = dateTimeOffset2.DateTime;
				return true;
			}
			case 'O':
			{
				if (!TryParseDateTimeOffsetO(source, out var value2, out bytesConsumed, out var kind))
				{
					value = default(DateTime);
					bytesConsumed = 0;
					return false;
				}
				switch (kind)
				{
				case DateTimeKind.Local:
					value = value2.LocalDateTime;
					break;
				case DateTimeKind.Utc:
					value = value2.UtcDateTime;
					break;
				default:
					value = value2.DateTime;
					break;
				}
				return true;
			}
			case '\0':
			case 'G':
			{
				DateTimeOffset valueAsOffset;
				return TryParseDateTimeG(source, out value, out valueAsOffset, out bytesConsumed);
			}
			default:
				return System.ThrowHelper.TryParseThrowFormatException<DateTime>(out value, out bytesConsumed);
			}
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out DateTimeOffset value, out int bytesConsumed, char standardFormat = '\0')
		{
			DateTimeKind kind;
			DateTime value2;
			return standardFormat switch
			{
				'R' => TryParseDateTimeOffsetR(source, 0u, out value, out bytesConsumed), 
				'l' => TryParseDateTimeOffsetR(source, 32u, out value, out bytesConsumed), 
				'O' => TryParseDateTimeOffsetO(source, out value, out bytesConsumed, out kind), 
				'\0' => TryParseDateTimeOffsetDefault(source, out value, out bytesConsumed), 
				'G' => TryParseDateTimeG(source, out value2, out value, out bytesConsumed), 
				_ => System.ThrowHelper.TryParseThrowFormatException<DateTimeOffset>(out value, out bytesConsumed), 
			};
		}

		private static bool TryParseDateTimeOffsetDefault(ReadOnlySpan<byte> source, out DateTimeOffset value, out int bytesConsumed)
		{
			if (source.Length < 26)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			if (!TryParseDateTimeG(source, out var value2, out var _, out var _))
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			if (source[19] != 32)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			byte b = source[20];
			if (b != 43 && b != 45)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			uint num = (uint)(source[21] - 48);
			uint num2 = (uint)(source[22] - 48);
			if (num > 9 || num2 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			int num3 = (int)(num * 10 + num2);
			if (source[23] != 58)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			uint num4 = (uint)(source[24] - 48);
			uint num5 = (uint)(source[25] - 48);
			if (num4 > 9 || num5 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			int num6 = (int)(num4 * 10 + num5);
			TimeSpan timeSpan = new TimeSpan(num3, num6, 0);
			if (b == 45)
			{
				timeSpan = -timeSpan;
			}
			if (!TryCreateDateTimeOffset(value2, b == 45, num3, num6, out value))
			{
				bytesConsumed = 0;
				value = default(DateTimeOffset);
				return false;
			}
			bytesConsumed = 26;
			return true;
		}

		private static bool TryParseDateTimeG(ReadOnlySpan<byte> source, out DateTime value, out DateTimeOffset valueAsOffset, out int bytesConsumed)
		{
			if (source.Length < 19)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num = (uint)(source[0] - 48);
			uint num2 = (uint)(source[1] - 48);
			if (num > 9 || num2 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int month = (int)(num * 10 + num2);
			if (source[2] != 47)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num3 = (uint)(source[3] - 48);
			uint num4 = (uint)(source[4] - 48);
			if (num3 > 9 || num4 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int day = (int)(num3 * 10 + num4);
			if (source[5] != 47)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num5 = (uint)(source[6] - 48);
			uint num6 = (uint)(source[7] - 48);
			uint num7 = (uint)(source[8] - 48);
			uint num8 = (uint)(source[9] - 48);
			if (num5 > 9 || num6 > 9 || num7 > 9 || num8 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int year = (int)(num5 * 1000 + num6 * 100 + num7 * 10 + num8);
			if (source[10] != 32)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num9 = (uint)(source[11] - 48);
			uint num10 = (uint)(source[12] - 48);
			if (num9 > 9 || num10 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int hour = (int)(num9 * 10 + num10);
			if (source[13] != 58)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num11 = (uint)(source[14] - 48);
			uint num12 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int minute = (int)(num11 * 10 + num12);
			if (source[16] != 58)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			uint num13 = (uint)(source[17] - 48);
			uint num14 = (uint)(source[18] - 48);
			if (num13 > 9 || num14 > 9)
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			int second = (int)(num13 * 10 + num14);
			if (!TryCreateDateTimeOffsetInterpretingDataAsLocalTime(year, month, day, hour, minute, second, 0, out valueAsOffset))
			{
				bytesConsumed = 0;
				value = default(DateTime);
				valueAsOffset = default(DateTimeOffset);
				return false;
			}
			bytesConsumed = 19;
			value = valueAsOffset.DateTime;
			return true;
		}

		private static bool TryCreateDateTimeOffset(DateTime dateTime, bool offsetNegative, int offsetHours, int offsetMinutes, out DateTimeOffset value)
		{
			if ((uint)offsetHours > 14u)
			{
				value = default(DateTimeOffset);
				return false;
			}
			if ((uint)offsetMinutes > 59u)
			{
				value = default(DateTimeOffset);
				return false;
			}
			if (offsetHours == 14 && offsetMinutes != 0)
			{
				value = default(DateTimeOffset);
				return false;
			}
			long num = ((long)offsetHours * 3600L + (long)offsetMinutes * 60L) * 10000000;
			if (offsetNegative)
			{
				num = -num;
			}
			try
			{
				value = new DateTimeOffset(dateTime.Ticks, new TimeSpan(num));
			}
			catch (ArgumentOutOfRangeException)
			{
				value = default(DateTimeOffset);
				return false;
			}
			return true;
		}

		private static bool TryCreateDateTimeOffset(int year, int month, int day, int hour, int minute, int second, int fraction, bool offsetNegative, int offsetHours, int offsetMinutes, out DateTimeOffset value)
		{
			if (!TryCreateDateTime(year, month, day, hour, minute, second, fraction, DateTimeKind.Unspecified, out var value2))
			{
				value = default(DateTimeOffset);
				return false;
			}
			if (!TryCreateDateTimeOffset(value2, offsetNegative, offsetHours, offsetMinutes, out value))
			{
				value = default(DateTimeOffset);
				return false;
			}
			return true;
		}

		private static bool TryCreateDateTimeOffsetInterpretingDataAsLocalTime(int year, int month, int day, int hour, int minute, int second, int fraction, out DateTimeOffset value)
		{
			if (!TryCreateDateTime(year, month, day, hour, minute, second, fraction, DateTimeKind.Local, out var value2))
			{
				value = default(DateTimeOffset);
				return false;
			}
			try
			{
				value = new DateTimeOffset(value2);
			}
			catch (ArgumentOutOfRangeException)
			{
				value = default(DateTimeOffset);
				return false;
			}
			return true;
		}

		private static bool TryCreateDateTime(int year, int month, int day, int hour, int minute, int second, int fraction, DateTimeKind kind, out DateTime value)
		{
			if (year == 0)
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)(month - 1) >= 12u)
			{
				value = default(DateTime);
				return false;
			}
			uint num = (uint)(day - 1);
			if (num >= 28 && num >= DateTime.DaysInMonth(year, month))
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)hour > 23u)
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)minute > 59u)
			{
				value = default(DateTime);
				return false;
			}
			if ((uint)second > 59u)
			{
				value = default(DateTime);
				return false;
			}
			int[] array = (DateTime.IsLeapYear(year) ? s_daysToMonth366 : s_daysToMonth365);
			int num2 = year - 1;
			int num3 = num2 * 365 + num2 / 4 - num2 / 100 + num2 / 400 + array[month - 1] + day - 1;
			long num4 = num3 * 864000000000L;
			int num5 = hour * 3600 + minute * 60 + second;
			num4 += (long)num5 * 10000000L;
			num4 += fraction;
			value = new DateTime(num4, kind);
			return true;
		}

		private static bool TryParseDateTimeOffsetO(ReadOnlySpan<byte> source, out DateTimeOffset value, out int bytesConsumed, out DateTimeKind kind)
		{
			if (source.Length < 27)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num = (uint)(source[0] - 48);
			uint num2 = (uint)(source[1] - 48);
			uint num3 = (uint)(source[2] - 48);
			uint num4 = (uint)(source[3] - 48);
			if (num > 9 || num2 > 9 || num3 > 9 || num4 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int year = (int)(num * 1000 + num2 * 100 + num3 * 10 + num4);
			if (source[4] != 45)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num5 = (uint)(source[5] - 48);
			uint num6 = (uint)(source[6] - 48);
			if (num5 > 9 || num6 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int month = (int)(num5 * 10 + num6);
			if (source[7] != 45)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num7 = (uint)(source[8] - 48);
			uint num8 = (uint)(source[9] - 48);
			if (num7 > 9 || num8 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int day = (int)(num7 * 10 + num8);
			if (source[10] != 84)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num9 = (uint)(source[11] - 48);
			uint num10 = (uint)(source[12] - 48);
			if (num9 > 9 || num10 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int hour = (int)(num9 * 10 + num10);
			if (source[13] != 58)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num11 = (uint)(source[14] - 48);
			uint num12 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int minute = (int)(num11 * 10 + num12);
			if (source[16] != 58)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num13 = (uint)(source[17] - 48);
			uint num14 = (uint)(source[18] - 48);
			if (num13 > 9 || num14 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int second = (int)(num13 * 10 + num14);
			if (source[19] != 46)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num15 = (uint)(source[20] - 48);
			uint num16 = (uint)(source[21] - 48);
			uint num17 = (uint)(source[22] - 48);
			uint num18 = (uint)(source[23] - 48);
			uint num19 = (uint)(source[24] - 48);
			uint num20 = (uint)(source[25] - 48);
			uint num21 = (uint)(source[26] - 48);
			if (num15 > 9 || num16 > 9 || num17 > 9 || num18 > 9 || num19 > 9 || num20 > 9 || num21 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int fraction = (int)(num15 * 1000000 + num16 * 100000 + num17 * 10000 + num18 * 1000 + num19 * 100 + num20 * 10 + num21);
			byte b = (byte)((source.Length > 27) ? source[27] : 0);
			if (b != 90 && b != 43 && b != 45)
			{
				if (!TryCreateDateTimeOffsetInterpretingDataAsLocalTime(year, month, day, hour, minute, second, fraction, out value))
				{
					value = default(DateTimeOffset);
					bytesConsumed = 0;
					kind = DateTimeKind.Unspecified;
					return false;
				}
				bytesConsumed = 27;
				kind = DateTimeKind.Unspecified;
				return true;
			}
			if (b == 90)
			{
				if (!TryCreateDateTimeOffset(year, month, day, hour, minute, second, fraction, offsetNegative: false, 0, 0, out value))
				{
					value = default(DateTimeOffset);
					bytesConsumed = 0;
					kind = DateTimeKind.Unspecified;
					return false;
				}
				bytesConsumed = 28;
				kind = DateTimeKind.Utc;
				return true;
			}
			if (source.Length < 33)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num22 = (uint)(source[28] - 48);
			uint num23 = (uint)(source[29] - 48);
			if (num22 > 9 || num23 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int offsetHours = (int)(num22 * 10 + num23);
			if (source[30] != 58)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			uint num24 = (uint)(source[31] - 48);
			uint num25 = (uint)(source[32] - 48);
			if (num24 > 9 || num25 > 9)
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			int offsetMinutes = (int)(num24 * 10 + num25);
			if (!TryCreateDateTimeOffset(year, month, day, hour, minute, second, fraction, b == 45, offsetHours, offsetMinutes, out value))
			{
				value = default(DateTimeOffset);
				bytesConsumed = 0;
				kind = DateTimeKind.Unspecified;
				return false;
			}
			bytesConsumed = 33;
			kind = DateTimeKind.Local;
			return true;
		}

		private static bool TryParseDateTimeOffsetR(ReadOnlySpan<byte> source, uint caseFlipXorMask, out DateTimeOffset dateTimeOffset, out int bytesConsumed)
		{
			if (source.Length < 29)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num = source[0] ^ caseFlipXorMask;
			uint num2 = source[1];
			uint num3 = source[2];
			uint num4 = source[3];
			DayOfWeek dayOfWeek;
			switch ((num << 24) | (num2 << 16) | (num3 << 8) | num4)
			{
			case 1400204844u:
				dayOfWeek = DayOfWeek.Sunday;
				break;
			case 1299148332u:
				dayOfWeek = DayOfWeek.Monday;
				break;
			case 1416979756u:
				dayOfWeek = DayOfWeek.Tuesday;
				break;
			case 1466262572u:
				dayOfWeek = DayOfWeek.Wednesday;
				break;
			case 1416131884u:
				dayOfWeek = DayOfWeek.Thursday;
				break;
			case 1181903148u:
				dayOfWeek = DayOfWeek.Friday;
				break;
			case 1398895660u:
				dayOfWeek = DayOfWeek.Saturday;
				break;
			default:
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			if (source[4] != 32)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num5 = (uint)(source[5] - 48);
			uint num6 = (uint)(source[6] - 48);
			if (num5 > 9 || num6 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int day = (int)(num5 * 10 + num6);
			if (source[7] != 32)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num7 = source[8] ^ caseFlipXorMask;
			uint num8 = source[9];
			uint num9 = source[10];
			uint num10 = source[11];
			int month;
			switch ((num7 << 24) | (num8 << 16) | (num9 << 8) | num10)
			{
			case 1247899168u:
				month = 1;
				break;
			case 1181049376u:
				month = 2;
				break;
			case 1298231840u:
				month = 3;
				break;
			case 1097888288u:
				month = 4;
				break;
			case 1298233632u:
				month = 5;
				break;
			case 1249209888u:
				month = 6;
				break;
			case 1249209376u:
				month = 7;
				break;
			case 1098213152u:
				month = 8;
				break;
			case 1399156768u:
				month = 9;
				break;
			case 1331917856u:
				month = 10;
				break;
			case 1315927584u:
				month = 11;
				break;
			case 1147495200u:
				month = 12;
				break;
			default:
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num11 = (uint)(source[12] - 48);
			uint num12 = (uint)(source[13] - 48);
			uint num13 = (uint)(source[14] - 48);
			uint num14 = (uint)(source[15] - 48);
			if (num11 > 9 || num12 > 9 || num13 > 9 || num14 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int year = (int)(num11 * 1000 + num12 * 100 + num13 * 10 + num14);
			if (source[16] != 32)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num15 = (uint)(source[17] - 48);
			uint num16 = (uint)(source[18] - 48);
			if (num15 > 9 || num16 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int hour = (int)(num15 * 10 + num16);
			if (source[19] != 58)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num17 = (uint)(source[20] - 48);
			uint num18 = (uint)(source[21] - 48);
			if (num17 > 9 || num18 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int minute = (int)(num17 * 10 + num18);
			if (source[22] != 58)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			uint num19 = (uint)(source[23] - 48);
			uint num20 = (uint)(source[24] - 48);
			if (num19 > 9 || num20 > 9)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			int second = (int)(num19 * 10 + num20);
			uint num21 = source[25];
			uint num22 = source[26] ^ caseFlipXorMask;
			uint num23 = source[27] ^ caseFlipXorMask;
			uint num24 = source[28] ^ caseFlipXorMask;
			uint num25 = (num21 << 24) | (num22 << 16) | (num23 << 8) | num24;
			if (num25 != 541543764)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			if (!TryCreateDateTimeOffset(year, month, day, hour, minute, second, 0, offsetNegative: false, 0, 0, out dateTimeOffset))
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			if (dayOfWeek != dateTimeOffset.DayOfWeek)
			{
				bytesConsumed = 0;
				dateTimeOffset = default(DateTimeOffset);
				return false;
			}
			bytesConsumed = 29;
			return true;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out decimal value, out int bytesConsumed, char standardFormat = '\0')
		{
			ParseNumberOptions options;
			switch (standardFormat)
			{
			case '\0':
			case 'E':
			case 'G':
			case 'e':
			case 'g':
				options = ParseNumberOptions.AllowExponent;
				break;
			case 'F':
			case 'f':
				options = (ParseNumberOptions)0;
				break;
			default:
				return System.ThrowHelper.TryParseThrowFormatException<decimal>(out value, out bytesConsumed);
			}
			NumberBuffer number = default(NumberBuffer);
			if (!TryParseNumber(source, ref number, out bytesConsumed, options, out var textUsedExponentNotation))
			{
				value = default(decimal);
				return false;
			}
			if (!textUsedExponentNotation && (standardFormat == 'E' || standardFormat == 'e'))
			{
				value = default(decimal);
				bytesConsumed = 0;
				return false;
			}
			if (number.Digits[0] == 0 && number.Scale == 0)
			{
				number.IsNegative = false;
			}
			value = default(decimal);
			if (!System.Number.NumberBufferToDecimal(ref number, ref value))
			{
				value = default(decimal);
				bytesConsumed = 0;
				return false;
			}
			return true;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out float value, out int bytesConsumed, char standardFormat = '\0')
		{
			if (TryParseNormalAsFloatingPoint(source, out var value2, out bytesConsumed, standardFormat))
			{
				value = (float)value2;
				if (float.IsInfinity(value))
				{
					value = 0f;
					bytesConsumed = 0;
					return false;
				}
				return true;
			}
			return TryParseAsSpecialFloatingPoint(source, float.PositiveInfinity, float.NegativeInfinity, float.NaN, out value, out bytesConsumed);
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out double value, out int bytesConsumed, char standardFormat = '\0')
		{
			if (TryParseNormalAsFloatingPoint(source, out value, out bytesConsumed, standardFormat))
			{
				return true;
			}
			return TryParseAsSpecialFloatingPoint(source, double.PositiveInfinity, double.NegativeInfinity, double.NaN, out value, out bytesConsumed);
		}

		private static bool TryParseNormalAsFloatingPoint(ReadOnlySpan<byte> source, out double value, out int bytesConsumed, char standardFormat)
		{
			ParseNumberOptions options;
			switch (standardFormat)
			{
			case '\0':
			case 'E':
			case 'G':
			case 'e':
			case 'g':
				options = ParseNumberOptions.AllowExponent;
				break;
			case 'F':
			case 'f':
				options = (ParseNumberOptions)0;
				break;
			default:
				return System.ThrowHelper.TryParseThrowFormatException<double>(out value, out bytesConsumed);
			}
			NumberBuffer number = default(NumberBuffer);
			if (!TryParseNumber(source, ref number, out bytesConsumed, options, out var textUsedExponentNotation))
			{
				value = 0.0;
				return false;
			}
			if (!textUsedExponentNotation && (standardFormat == 'E' || standardFormat == 'e'))
			{
				value = 0.0;
				bytesConsumed = 0;
				return false;
			}
			if (number.Digits[0] == 0)
			{
				number.IsNegative = false;
			}
			if (!System.Number.NumberBufferToDouble(ref number, out value))
			{
				value = 0.0;
				bytesConsumed = 0;
				return false;
			}
			return true;
		}

		private static bool TryParseAsSpecialFloatingPoint<T>(ReadOnlySpan<byte> source, T positiveInfinity, T negativeInfinity, T nan, out T value, out int bytesConsumed)
		{
			if (source.Length >= 8 && source[0] == 73 && source[1] == 110 && source[2] == 102 && source[3] == 105 && source[4] == 110 && source[5] == 105 && source[6] == 116 && source[7] == 121)
			{
				value = positiveInfinity;
				bytesConsumed = 8;
				return true;
			}
			if (source.Length >= 9 && source[0] == 45 && source[1] == 73 && source[2] == 110 && source[3] == 102 && source[4] == 105 && source[5] == 110 && source[6] == 105 && source[7] == 116 && source[8] == 121)
			{
				value = negativeInfinity;
				bytesConsumed = 9;
				return true;
			}
			if (source.Length >= 3 && source[0] == 78 && source[1] == 97 && source[2] == 78)
			{
				value = nan;
				bytesConsumed = 3;
				return true;
			}
			value = default(T);
			bytesConsumed = 0;
			return false;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out Guid value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
				return TryParseGuidCore(source, ends: false, ' ', ' ', out value, out bytesConsumed);
			case 'B':
				return TryParseGuidCore(source, ends: true, '{', '}', out value, out bytesConsumed);
			case 'P':
				return TryParseGuidCore(source, ends: true, '(', ')', out value, out bytesConsumed);
			case 'N':
				return TryParseGuidN(source, out value, out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<Guid>(out value, out bytesConsumed);
			}
		}

		private static bool TryParseGuidN(ReadOnlySpan<byte> text, out Guid value, out int bytesConsumed)
		{
			if (text.Length < 32)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32X(text.Slice(0, 8), out var value2, out var bytesConsumed2) || bytesConsumed2 != 8)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt16X(text.Slice(8, 4), out var value3, out bytesConsumed2) || bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt16X(text.Slice(12, 4), out var value4, out bytesConsumed2) || bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt16X(text.Slice(16, 4), out var value5, out bytesConsumed2) || bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt64X(text.Slice(20), out var value6, out bytesConsumed2) || bytesConsumed2 != 12)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			bytesConsumed = 32;
			value = new Guid((int)value2, (short)value3, (short)value4, (byte)(value5 >> 8), (byte)value5, (byte)(value6 >> 40), (byte)(value6 >> 32), (byte)(value6 >> 24), (byte)(value6 >> 16), (byte)(value6 >> 8), (byte)value6);
			return true;
		}

		private static bool TryParseGuidCore(ReadOnlySpan<byte> source, bool ends, char begin, char end, out Guid value, out int bytesConsumed)
		{
			int num = 36 + (ends ? 2 : 0);
			if (source.Length < num)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (ends)
			{
				if (source[0] != begin)
				{
					value = default(Guid);
					bytesConsumed = 0;
					return false;
				}
				source = source.Slice(1);
			}
			if (!TryParseUInt32X(source, out var value2, out var bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 8)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(9);
			if (!TryParseUInt16X(source, out var value3, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(5);
			if (!TryParseUInt16X(source, out var value4, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(5);
			if (!TryParseUInt16X(source, out var value5, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 4)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (source[bytesConsumed2] != 45)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			source = source.Slice(5);
			if (!TryParseUInt64X(source, out var value6, out bytesConsumed2))
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (bytesConsumed2 != 12)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			if (ends && source[bytesConsumed2] != end)
			{
				value = default(Guid);
				bytesConsumed = 0;
				return false;
			}
			bytesConsumed = num;
			value = new Guid((int)value2, (short)value3, (short)value4, (byte)(value5 >> 8), (byte)value5, (byte)(value6 >> 40), (byte)(value6 >> 32), (byte)(value6 >> 24), (byte)(value6 >> 16), (byte)(value6 >> 8), (byte)value6);
			return true;
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseSByteD(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseSByteN(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				value = 0;
				return TryParseByteX(source, out Unsafe.As<sbyte, byte>(ref value), out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<sbyte>(out value, out bytesConsumed);
			}
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out short value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseInt16D(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseInt16N(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				value = 0;
				return TryParseUInt16X(source, out Unsafe.As<short, ushort>(ref value), out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<short>(out value, out bytesConsumed);
			}
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out int value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseInt32D(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseInt32N(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				value = 0;
				return TryParseUInt32X(source, out Unsafe.As<int, uint>(ref value), out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<int>(out value, out bytesConsumed);
			}
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out long value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseInt64D(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseInt64N(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				value = 0L;
				return TryParseUInt64X(source, out Unsafe.As<long, ulong>(ref value), out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<long>(out value, out bytesConsumed);
			}
		}

		private static bool TryParseSByteD(ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0123;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0123;
					}
					num3 = source[num2];
				}
				num4 = 0;
				if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
				{
					if (num3 != 48)
					{
						goto IL_009c;
					}
					while (true)
					{
						num2++;
						if ((uint)num2 >= (uint)source.Length)
						{
							break;
						}
						num3 = source[num2];
						if (num3 == 48)
						{
							continue;
						}
						goto IL_0091;
					}
					goto IL_012b;
				}
			}
			goto IL_0123;
			IL_0123:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0091:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
			{
				goto IL_009c;
			}
			goto IL_012b;
			IL_012b:
			bytesConsumed = num2;
			value = (sbyte)(num4 * num);
			return true;
			IL_009c:
			num4 = num3 - 48;
			num2++;
			if ((uint)num2 < (uint)source.Length)
			{
				num3 = source[num2];
				if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
				{
					num2++;
					num4 = 10 * num4 + num3 - 48;
					if ((uint)num2 < (uint)source.Length)
					{
						num3 = source[num2];
						if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
						{
							num2++;
							num4 = num4 * 10 + num3 - 48;
							if ((uint)num4 > 127L + (long)((-1 * num + 1) / 2) || ((uint)num2 < (uint)source.Length && System.Buffers.Text.ParserHelpers.IsDigit(source[num2])))
							{
								goto IL_0123;
							}
						}
					}
				}
			}
			goto IL_012b;
		}

		private static bool TryParseInt16D(ReadOnlySpan<byte> source, out short value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0186;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0186;
					}
					num3 = source[num2];
				}
				num4 = 0;
				if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
				{
					if (num3 != 48)
					{
						goto IL_009c;
					}
					while (true)
					{
						num2++;
						if ((uint)num2 >= (uint)source.Length)
						{
							break;
						}
						num3 = source[num2];
						if (num3 == 48)
						{
							continue;
						}
						goto IL_0091;
					}
					goto IL_018e;
				}
			}
			goto IL_0186;
			IL_0186:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0091:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
			{
				goto IL_009c;
			}
			goto IL_018e;
			IL_018e:
			bytesConsumed = num2;
			value = (short)(num4 * num);
			return true;
			IL_009c:
			num4 = num3 - 48;
			num2++;
			if ((uint)num2 < (uint)source.Length)
			{
				num3 = source[num2];
				if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
				{
					num2++;
					num4 = 10 * num4 + num3 - 48;
					if ((uint)num2 < (uint)source.Length)
					{
						num3 = source[num2];
						if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
						{
							num2++;
							num4 = 10 * num4 + num3 - 48;
							if ((uint)num2 < (uint)source.Length)
							{
								num3 = source[num2];
								if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
								{
									num2++;
									num4 = 10 * num4 + num3 - 48;
									if ((uint)num2 < (uint)source.Length)
									{
										num3 = source[num2];
										if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
										{
											num2++;
											num4 = num4 * 10 + num3 - 48;
											if ((uint)num4 > 32767L + (long)((-1 * num + 1) / 2) || ((uint)num2 < (uint)source.Length && System.Buffers.Text.ParserHelpers.IsDigit(source[num2])))
											{
												goto IL_0186;
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_018e;
		}

		private static bool TryParseInt32D(ReadOnlySpan<byte> source, out int value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0281;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0281;
					}
					num3 = source[num2];
				}
				num4 = 0;
				if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
				{
					if (num3 != 48)
					{
						goto IL_009c;
					}
					while (true)
					{
						num2++;
						if ((uint)num2 >= (uint)source.Length)
						{
							break;
						}
						num3 = source[num2];
						if (num3 == 48)
						{
							continue;
						}
						goto IL_0091;
					}
					goto IL_0289;
				}
			}
			goto IL_0281;
			IL_0281:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0091:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
			{
				goto IL_009c;
			}
			goto IL_0289;
			IL_0289:
			bytesConsumed = num2;
			value = num4 * num;
			return true;
			IL_009c:
			num4 = num3 - 48;
			num2++;
			if ((uint)num2 < (uint)source.Length)
			{
				num3 = source[num2];
				if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
				{
					num2++;
					num4 = 10 * num4 + num3 - 48;
					if ((uint)num2 < (uint)source.Length)
					{
						num3 = source[num2];
						if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
						{
							num2++;
							num4 = 10 * num4 + num3 - 48;
							if ((uint)num2 < (uint)source.Length)
							{
								num3 = source[num2];
								if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
								{
									num2++;
									num4 = 10 * num4 + num3 - 48;
									if ((uint)num2 < (uint)source.Length)
									{
										num3 = source[num2];
										if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
										{
											num2++;
											num4 = 10 * num4 + num3 - 48;
											if ((uint)num2 < (uint)source.Length)
											{
												num3 = source[num2];
												if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
												{
													num2++;
													num4 = 10 * num4 + num3 - 48;
													if ((uint)num2 < (uint)source.Length)
													{
														num3 = source[num2];
														if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
														{
															num2++;
															num4 = 10 * num4 + num3 - 48;
															if ((uint)num2 < (uint)source.Length)
															{
																num3 = source[num2];
																if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
																{
																	num2++;
																	num4 = 10 * num4 + num3 - 48;
																	if ((uint)num2 < (uint)source.Length)
																	{
																		num3 = source[num2];
																		if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
																		{
																			num2++;
																			num4 = 10 * num4 + num3 - 48;
																			if ((uint)num2 < (uint)source.Length)
																			{
																				num3 = source[num2];
																				if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
																				{
																					num2++;
																					if (num4 <= 214748364)
																					{
																						num4 = num4 * 10 + num3 - 48;
																						if ((uint)num4 <= 2147483647L + (long)((-1 * num + 1) / 2) && ((uint)num2 >= (uint)source.Length || !System.Buffers.Text.ParserHelpers.IsDigit(source[num2])))
																						{
																							goto IL_0289;
																						}
																					}
																					goto IL_0281;
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_0289;
		}

		private static bool TryParseInt64D(ReadOnlySpan<byte> source, out long value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0L;
				return false;
			}
			int num = 0;
			int num2 = 1;
			if (source[0] == 45)
			{
				num = 1;
				num2 = -1;
				if (source.Length <= num)
				{
					bytesConsumed = 0;
					value = 0L;
					return false;
				}
			}
			else if (source[0] == 43)
			{
				num = 1;
				if (source.Length <= num)
				{
					bytesConsumed = 0;
					value = 0L;
					return false;
				}
			}
			int num3 = 19 + num;
			long num4 = source[num] - 48;
			if (num4 < 0 || num4 > 9)
			{
				bytesConsumed = 0;
				value = 0L;
				return false;
			}
			ulong num5 = (ulong)num4;
			if (source.Length < num3)
			{
				for (int i = num + 1; i < source.Length; i++)
				{
					long num6 = source[i] - 48;
					if (num6 < 0 || num6 > 9)
					{
						bytesConsumed = i;
						value = (long)num5 * (long)num2;
						return true;
					}
					num5 = num5 * 10 + (ulong)num6;
				}
			}
			else
			{
				for (int j = num + 1; j < num3 - 1; j++)
				{
					long num7 = source[j] - 48;
					if (num7 < 0 || num7 > 9)
					{
						bytesConsumed = j;
						value = (long)num5 * (long)num2;
						return true;
					}
					num5 = num5 * 10 + (ulong)num7;
				}
				for (int k = num3 - 1; k < source.Length; k++)
				{
					long num8 = source[k] - 48;
					if (num8 < 0 || num8 > 9)
					{
						bytesConsumed = k;
						value = (long)num5 * (long)num2;
						return true;
					}
					bool flag = num2 > 0;
					bool flag2 = num8 > 8 || (flag && num8 > 7);
					if (num5 > 922337203685477580L || (num5 == 922337203685477580L && flag2))
					{
						bytesConsumed = 0;
						value = 0L;
						return false;
					}
					num5 = num5 * 10 + (ulong)num8;
				}
			}
			bytesConsumed = source.Length;
			value = (long)num5 * (long)num2;
			return true;
		}

		private static bool TryParseSByteN(ReadOnlySpan<byte> source, out sbyte value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00f9;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00f9;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00d4;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num3))
							{
								break;
							}
							num4 = num4 * 10 + num3 - 48;
							if (num4 <= 127 + (-1 * num + 1) / 2)
							{
								continue;
							}
							goto IL_00f9;
						}
						goto IL_0101;
					}
				}
				else
				{
					num4 = 0;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00d4;
					}
				}
			}
			goto IL_00f9;
			IL_00f9:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0101:
			bytesConsumed = num2;
			value = (sbyte)(num4 * num);
			return true;
			IL_00d4:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_00f1;
			}
			goto IL_0101;
			IL_00f1:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
			{
				goto IL_00f9;
			}
			goto IL_0101;
		}

		private static bool TryParseInt16N(ReadOnlySpan<byte> source, out short value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00ff;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_00ff;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00da;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num3))
							{
								break;
							}
							num4 = num4 * 10 + num3 - 48;
							if (num4 <= 32767 + (-1 * num + 1) / 2)
							{
								continue;
							}
							goto IL_00ff;
						}
						goto IL_0107;
					}
				}
				else
				{
					num4 = 0;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00da;
					}
				}
			}
			goto IL_00ff;
			IL_00ff:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0107:
			bytesConsumed = num2;
			value = (short)(num4 * num);
			return true;
			IL_00da:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_00f7;
			}
			goto IL_0107;
			IL_00f7:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
			{
				goto IL_00ff;
			}
			goto IL_0107;
		}

		private static bool TryParseInt32N(ReadOnlySpan<byte> source, out int value, out int bytesConsumed)
		{
			int num;
			int num2;
			int num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_010a;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_010a;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00e5;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num3))
							{
								break;
							}
							if ((uint)num4 <= 214748364u)
							{
								num4 = num4 * 10 + num3 - 48;
								if ((uint)num4 <= 2147483647L + (long)((-1 * num + 1) / 2))
								{
									continue;
								}
							}
							goto IL_010a;
						}
						goto IL_0112;
					}
				}
				else
				{
					num4 = 0;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00e5;
					}
				}
			}
			goto IL_010a;
			IL_010a:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_0112:
			bytesConsumed = num2;
			value = num4 * num;
			return true;
			IL_00e5:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_0102;
			}
			goto IL_0112;
			IL_0102:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
			{
				goto IL_010a;
			}
			goto IL_0112;
		}

		private static bool TryParseInt64N(ReadOnlySpan<byte> source, out long value, out int bytesConsumed)
		{
			int num;
			int num2;
			long num4;
			int num3;
			if (source.Length >= 1)
			{
				num = 1;
				num2 = 0;
				num3 = source[num2];
				if (num3 == 45)
				{
					num = -1;
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0115;
					}
					num3 = source[num2];
				}
				else if (num3 == 43)
				{
					num2++;
					if ((uint)num2 >= (uint)source.Length)
					{
						goto IL_0115;
					}
					num3 = source[num2];
				}
				if (num3 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
					{
						num4 = num3 - 48;
						while (true)
						{
							num2++;
							if ((uint)num2 >= (uint)source.Length)
							{
								break;
							}
							num3 = source[num2];
							if (num3 == 44)
							{
								continue;
							}
							if (num3 == 46)
							{
								goto IL_00f0;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num3))
							{
								break;
							}
							if ((ulong)num4 <= 922337203685477580uL)
							{
								num4 = num4 * 10 + num3 - 48;
								if ((ulong)num4 <= (ulong)(long.MaxValue + (-1 * num + 1) / 2))
								{
									continue;
								}
							}
							goto IL_0115;
						}
						goto IL_011e;
					}
				}
				else
				{
					num4 = 0L;
					num2++;
					if ((uint)num2 < (uint)source.Length && source[num2] == 48)
					{
						goto IL_00f0;
					}
				}
			}
			goto IL_0115;
			IL_0115:
			bytesConsumed = 0;
			value = 0L;
			return false;
			IL_011e:
			bytesConsumed = num2;
			value = num4 * num;
			return true;
			IL_00f0:
			while (true)
			{
				num2++;
				if ((uint)num2 >= (uint)source.Length)
				{
					break;
				}
				num3 = source[num2];
				if (num3 == 48)
				{
					continue;
				}
				goto IL_010d;
			}
			goto IL_011e;
			IL_010d:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num3))
			{
				goto IL_0115;
			}
			goto IL_011e;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseByteD(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseByteN(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				return TryParseByteX(source, out value, out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<byte>(out value, out bytesConsumed);
			}
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseUInt16D(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseUInt16N(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				return TryParseUInt16X(source, out value, out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<ushort>(out value, out bytesConsumed);
			}
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseUInt32D(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseUInt32N(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				return TryParseUInt32X(source, out value, out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<uint>(out value, out bytesConsumed);
			}
		}

		[CLSCompliant(false)]
		public static bool TryParse(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'D':
			case 'G':
			case 'd':
			case 'g':
				return TryParseUInt64D(source, out value, out bytesConsumed);
			case 'N':
			case 'n':
				return TryParseUInt64N(source, out value, out bytesConsumed);
			case 'X':
			case 'x':
				return TryParseUInt64X(source, out value, out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<ulong>(out value, out bytesConsumed);
			}
		}

		private static bool TryParseByteD(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				num3 = 0;
				if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
				{
					if (num2 != 48)
					{
						goto IL_0056;
					}
					while (true)
					{
						num++;
						if ((uint)num >= (uint)source.Length)
						{
							break;
						}
						num2 = source[num];
						if (num2 == 48)
						{
							continue;
						}
						goto IL_004b;
					}
					goto IL_00dd;
				}
			}
			goto IL_00d5;
			IL_004b:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
			{
				goto IL_0056;
			}
			goto IL_00dd;
			IL_0056:
			num3 = num2 - 48;
			num++;
			if ((uint)num < (uint)source.Length)
			{
				num2 = source[num];
				if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
				{
					num++;
					num3 = 10 * num3 + num2 - 48;
					if ((uint)num < (uint)source.Length)
					{
						num2 = source[num];
						if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
						{
							num++;
							num3 = num3 * 10 + num2 - 48;
							if ((uint)num3 > 255u || ((uint)num < (uint)source.Length && System.Buffers.Text.ParserHelpers.IsDigit(source[num])))
							{
								goto IL_00d5;
							}
						}
					}
				}
			}
			goto IL_00dd;
			IL_00dd:
			bytesConsumed = num;
			value = (byte)num3;
			return true;
			IL_00d5:
			bytesConsumed = 0;
			value = 0;
			return false;
		}

		private static bool TryParseUInt16D(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				num3 = 0;
				if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
				{
					if (num2 != 48)
					{
						goto IL_0056;
					}
					while (true)
					{
						num++;
						if ((uint)num >= (uint)source.Length)
						{
							break;
						}
						num2 = source[num];
						if (num2 == 48)
						{
							continue;
						}
						goto IL_004b;
					}
					goto IL_013d;
				}
			}
			goto IL_0135;
			IL_004b:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
			{
				goto IL_0056;
			}
			goto IL_013d;
			IL_0056:
			num3 = num2 - 48;
			num++;
			if ((uint)num < (uint)source.Length)
			{
				num2 = source[num];
				if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
				{
					num++;
					num3 = 10 * num3 + num2 - 48;
					if ((uint)num < (uint)source.Length)
					{
						num2 = source[num];
						if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
						{
							num++;
							num3 = 10 * num3 + num2 - 48;
							if ((uint)num < (uint)source.Length)
							{
								num2 = source[num];
								if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
								{
									num++;
									num3 = 10 * num3 + num2 - 48;
									if ((uint)num < (uint)source.Length)
									{
										num2 = source[num];
										if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
										{
											num++;
											num3 = num3 * 10 + num2 - 48;
											if ((uint)num3 > 65535u || ((uint)num < (uint)source.Length && System.Buffers.Text.ParserHelpers.IsDigit(source[num])))
											{
												goto IL_0135;
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_013d;
			IL_013d:
			bytesConsumed = num;
			value = (ushort)num3;
			return true;
			IL_0135:
			bytesConsumed = 0;
			value = 0;
			return false;
		}

		private static bool TryParseUInt32D(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				num3 = 0;
				if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
				{
					if (num2 != 48)
					{
						goto IL_0056;
					}
					while (true)
					{
						num++;
						if ((uint)num >= (uint)source.Length)
						{
							break;
						}
						num2 = source[num];
						if (num2 == 48)
						{
							continue;
						}
						goto IL_004b;
					}
					goto IL_023d;
				}
			}
			goto IL_0235;
			IL_004b:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
			{
				goto IL_0056;
			}
			goto IL_023d;
			IL_0056:
			num3 = num2 - 48;
			num++;
			if ((uint)num < (uint)source.Length)
			{
				num2 = source[num];
				if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
				{
					num++;
					num3 = 10 * num3 + num2 - 48;
					if ((uint)num < (uint)source.Length)
					{
						num2 = source[num];
						if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
						{
							num++;
							num3 = 10 * num3 + num2 - 48;
							if ((uint)num < (uint)source.Length)
							{
								num2 = source[num];
								if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
								{
									num++;
									num3 = 10 * num3 + num2 - 48;
									if ((uint)num < (uint)source.Length)
									{
										num2 = source[num];
										if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
										{
											num++;
											num3 = 10 * num3 + num2 - 48;
											if ((uint)num < (uint)source.Length)
											{
												num2 = source[num];
												if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
												{
													num++;
													num3 = 10 * num3 + num2 - 48;
													if ((uint)num < (uint)source.Length)
													{
														num2 = source[num];
														if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
														{
															num++;
															num3 = 10 * num3 + num2 - 48;
															if ((uint)num < (uint)source.Length)
															{
																num2 = source[num];
																if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
																{
																	num++;
																	num3 = 10 * num3 + num2 - 48;
																	if ((uint)num < (uint)source.Length)
																	{
																		num2 = source[num];
																		if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
																		{
																			num++;
																			num3 = 10 * num3 + num2 - 48;
																			if ((uint)num < (uint)source.Length)
																			{
																				num2 = source[num];
																				if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
																				{
																					num++;
																					if ((uint)num3 <= 429496729u && (num3 != 429496729 || num2 <= 53))
																					{
																						num3 = num3 * 10 + num2 - 48;
																						if ((uint)num >= (uint)source.Length || !System.Buffers.Text.ParserHelpers.IsDigit(source[num]))
																						{
																							goto IL_023d;
																						}
																					}
																					goto IL_0235;
																				}
																			}
																		}
																	}
																}
															}
														}
													}
												}
											}
										}
									}
								}
							}
						}
					}
				}
			}
			goto IL_023d;
			IL_023d:
			bytesConsumed = num;
			value = (uint)num3;
			return true;
			IL_0235:
			bytesConsumed = 0;
			value = 0u;
			return false;
		}

		private static bool TryParseUInt64D(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0uL;
				return false;
			}
			ulong num = (uint)(source[0] - 48);
			if (num > 9)
			{
				bytesConsumed = 0;
				value = 0uL;
				return false;
			}
			ulong num2 = num;
			if (source.Length < 19)
			{
				for (int i = 1; i < source.Length; i++)
				{
					ulong num3 = (uint)(source[i] - 48);
					if (num3 > 9)
					{
						bytesConsumed = i;
						value = num2;
						return true;
					}
					num2 = num2 * 10 + num3;
				}
			}
			else
			{
				for (int j = 1; j < 18; j++)
				{
					ulong num4 = (uint)(source[j] - 48);
					if (num4 > 9)
					{
						bytesConsumed = j;
						value = num2;
						return true;
					}
					num2 = num2 * 10 + num4;
				}
				for (int k = 18; k < source.Length; k++)
				{
					ulong num5 = (uint)(source[k] - 48);
					if (num5 > 9)
					{
						bytesConsumed = k;
						value = num2;
						return true;
					}
					if (num2 > 1844674407370955161L || (num2 == 1844674407370955161L && num5 > 5))
					{
						bytesConsumed = 0;
						value = 0uL;
						return false;
					}
					num2 = num2 * 10 + num5;
				}
			}
			bytesConsumed = source.Length;
			value = num2;
			return true;
		}

		private static bool TryParseByteN(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00ce;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00a9;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num2))
							{
								break;
							}
							num3 = num3 * 10 + num2 - 48;
							if (num3 <= 255)
							{
								continue;
							}
							goto IL_00ce;
						}
						goto IL_00d6;
					}
				}
				else
				{
					num3 = 0;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00a9;
					}
				}
			}
			goto IL_00ce;
			IL_00c6:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
			{
				goto IL_00ce;
			}
			goto IL_00d6;
			IL_00ce:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_00d6:
			bytesConsumed = num;
			value = (byte)num3;
			return true;
			IL_00a9:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00c6;
			}
			goto IL_00d6;
		}

		private static bool TryParseUInt16N(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00ce;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00a9;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num2))
							{
								break;
							}
							num3 = num3 * 10 + num2 - 48;
							if (num3 <= 65535)
							{
								continue;
							}
							goto IL_00ce;
						}
						goto IL_00d6;
					}
				}
				else
				{
					num3 = 0;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00a9;
					}
				}
			}
			goto IL_00ce;
			IL_00c6:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
			{
				goto IL_00ce;
			}
			goto IL_00d6;
			IL_00ce:
			bytesConsumed = 0;
			value = 0;
			return false;
			IL_00d6:
			bytesConsumed = num;
			value = (ushort)num3;
			return true;
			IL_00a9:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00c6;
			}
			goto IL_00d6;
		}

		private static bool TryParseUInt32N(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			int num;
			int num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00de;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00b9;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num2))
							{
								break;
							}
							if ((uint)num3 <= 429496729u && (num3 != 429496729 || num2 <= 53))
							{
								num3 = num3 * 10 + num2 - 48;
								continue;
							}
							goto IL_00de;
						}
						goto IL_00e6;
					}
				}
				else
				{
					num3 = 0;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00b9;
					}
				}
			}
			goto IL_00de;
			IL_00d6:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
			{
				goto IL_00de;
			}
			goto IL_00e6;
			IL_00de:
			bytesConsumed = 0;
			value = 0u;
			return false;
			IL_00e6:
			bytesConsumed = num;
			value = (uint)num3;
			return true;
			IL_00b9:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00d6;
			}
			goto IL_00e6;
		}

		private static bool TryParseUInt64N(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed)
		{
			int num;
			long num3;
			int num2;
			if (source.Length >= 1)
			{
				num = 0;
				num2 = source[num];
				if (num2 == 43)
				{
					num++;
					if ((uint)num >= (uint)source.Length)
					{
						goto IL_00eb;
					}
					num2 = source[num];
				}
				if (num2 != 46)
				{
					if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
					{
						num3 = num2 - 48;
						while (true)
						{
							num++;
							if ((uint)num >= (uint)source.Length)
							{
								break;
							}
							num2 = source[num];
							if (num2 == 44)
							{
								continue;
							}
							if (num2 == 46)
							{
								goto IL_00c6;
							}
							if (!System.Buffers.Text.ParserHelpers.IsDigit(num2))
							{
								break;
							}
							if ((ulong)num3 <= 1844674407370955161uL && (num3 != 1844674407370955161L || num2 <= 53))
							{
								num3 = num3 * 10 + num2 - 48;
								continue;
							}
							goto IL_00eb;
						}
						goto IL_00f4;
					}
				}
				else
				{
					num3 = 0L;
					num++;
					if ((uint)num < (uint)source.Length && source[num] == 48)
					{
						goto IL_00c6;
					}
				}
			}
			goto IL_00eb;
			IL_00e3:
			if (System.Buffers.Text.ParserHelpers.IsDigit(num2))
			{
				goto IL_00eb;
			}
			goto IL_00f4;
			IL_00eb:
			bytesConsumed = 0;
			value = 0uL;
			return false;
			IL_00f4:
			bytesConsumed = num;
			value = (ulong)num3;
			return true;
			IL_00c6:
			while (true)
			{
				num++;
				if ((uint)num >= (uint)source.Length)
				{
					break;
				}
				num2 = source[num];
				if (num2 == 48)
				{
					continue;
				}
				goto IL_00e3;
			}
			goto IL_00f4;
		}

		private static bool TryParseByteX(ReadOnlySpan<byte> source, out byte value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			byte[] s_hexLookup = System.Buffers.Text.ParserHelpers.s_hexLookup;
			byte b = source[0];
			byte b2 = s_hexLookup[b];
			if (b2 == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			uint num = b2;
			if (source.Length <= 2)
			{
				for (int i = 1; i < source.Length; i++)
				{
					b = source[i];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = i;
						value = (byte)num;
						return true;
					}
					num = (num << 4) + b2;
				}
			}
			else
			{
				for (int j = 1; j < 2; j++)
				{
					b = source[j];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = j;
						value = (byte)num;
						return true;
					}
					num = (num << 4) + b2;
				}
				for (int k = 2; k < source.Length; k++)
				{
					b = source[k];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = k;
						value = (byte)num;
						return true;
					}
					if (num > 15)
					{
						bytesConsumed = 0;
						value = 0;
						return false;
					}
					num = (num << 4) + b2;
				}
			}
			bytesConsumed = source.Length;
			value = (byte)num;
			return true;
		}

		private static bool TryParseUInt16X(ReadOnlySpan<byte> source, out ushort value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			byte[] s_hexLookup = System.Buffers.Text.ParserHelpers.s_hexLookup;
			byte b = source[0];
			byte b2 = s_hexLookup[b];
			if (b2 == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0;
				return false;
			}
			uint num = b2;
			if (source.Length <= 4)
			{
				for (int i = 1; i < source.Length; i++)
				{
					b = source[i];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = i;
						value = (ushort)num;
						return true;
					}
					num = (num << 4) + b2;
				}
			}
			else
			{
				for (int j = 1; j < 4; j++)
				{
					b = source[j];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = j;
						value = (ushort)num;
						return true;
					}
					num = (num << 4) + b2;
				}
				for (int k = 4; k < source.Length; k++)
				{
					b = source[k];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = k;
						value = (ushort)num;
						return true;
					}
					if (num > 4095)
					{
						bytesConsumed = 0;
						value = 0;
						return false;
					}
					num = (num << 4) + b2;
				}
			}
			bytesConsumed = source.Length;
			value = (ushort)num;
			return true;
		}

		private static bool TryParseUInt32X(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0u;
				return false;
			}
			byte[] s_hexLookup = System.Buffers.Text.ParserHelpers.s_hexLookup;
			byte b = source[0];
			byte b2 = s_hexLookup[b];
			if (b2 == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0u;
				return false;
			}
			uint num = b2;
			if (source.Length <= 8)
			{
				for (int i = 1; i < source.Length; i++)
				{
					b = source[i];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = i;
						value = num;
						return true;
					}
					num = (num << 4) + b2;
				}
			}
			else
			{
				for (int j = 1; j < 8; j++)
				{
					b = source[j];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = j;
						value = num;
						return true;
					}
					num = (num << 4) + b2;
				}
				for (int k = 8; k < source.Length; k++)
				{
					b = source[k];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = k;
						value = num;
						return true;
					}
					if (num > 268435455)
					{
						bytesConsumed = 0;
						value = 0u;
						return false;
					}
					num = (num << 4) + b2;
				}
			}
			bytesConsumed = source.Length;
			value = num;
			return true;
		}

		private static bool TryParseUInt64X(ReadOnlySpan<byte> source, out ulong value, out int bytesConsumed)
		{
			if (source.Length < 1)
			{
				bytesConsumed = 0;
				value = 0uL;
				return false;
			}
			byte[] s_hexLookup = System.Buffers.Text.ParserHelpers.s_hexLookup;
			byte b = source[0];
			byte b2 = s_hexLookup[b];
			if (b2 == byte.MaxValue)
			{
				bytesConsumed = 0;
				value = 0uL;
				return false;
			}
			ulong num = b2;
			if (source.Length <= 16)
			{
				for (int i = 1; i < source.Length; i++)
				{
					b = source[i];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = i;
						value = num;
						return true;
					}
					num = (num << 4) + b2;
				}
			}
			else
			{
				for (int j = 1; j < 16; j++)
				{
					b = source[j];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = j;
						value = num;
						return true;
					}
					num = (num << 4) + b2;
				}
				for (int k = 16; k < source.Length; k++)
				{
					b = source[k];
					b2 = s_hexLookup[b];
					if (b2 == byte.MaxValue)
					{
						bytesConsumed = k;
						value = num;
						return true;
					}
					if (num > 1152921504606846975L)
					{
						bytesConsumed = 0;
						value = 0uL;
						return false;
					}
					num = (num << 4) + b2;
				}
			}
			bytesConsumed = source.Length;
			value = num;
			return true;
		}

		private static bool TryParseNumber(ReadOnlySpan<byte> source, ref NumberBuffer number, out int bytesConsumed, ParseNumberOptions options, out bool textUsedExponentNotation)
		{
			textUsedExponentNotation = false;
			if (source.Length == 0)
			{
				bytesConsumed = 0;
				return false;
			}
			Span<byte> digits = number.Digits;
			int i = 0;
			int num = 0;
			byte b = source[i];
			if (b != 43)
			{
				if (b != 45)
				{
					goto IL_0055;
				}
				number.IsNegative = true;
			}
			i++;
			if (i == source.Length)
			{
				bytesConsumed = 0;
				return false;
			}
			b = source[i];
			goto IL_0055;
			IL_0055:
			int num2 = i;
			for (; i != source.Length; i++)
			{
				b = source[i];
				if (b != 48)
				{
					break;
				}
			}
			if (i == source.Length)
			{
				digits[0] = 0;
				number.Scale = 0;
				bytesConsumed = i;
				return true;
			}
			int num3 = i;
			for (; i != source.Length; i++)
			{
				b = source[i];
				if ((uint)(b - 48) > 9u)
				{
					break;
				}
			}
			int num4 = i - num2;
			int num5 = i - num3;
			int num6 = Math.Min(num5, 50);
			source.Slice(num3, num6).CopyTo(digits);
			num = num6;
			number.Scale = num5;
			if (i == source.Length)
			{
				bytesConsumed = i;
				return true;
			}
			int num7 = 0;
			if (b == 46)
			{
				i++;
				int num8 = i;
				for (; i != source.Length; i++)
				{
					b = source[i];
					if ((uint)(b - 48) > 9u)
					{
						break;
					}
				}
				num7 = i - num8;
				int j = num8;
				if (num == 0)
				{
					for (; j < i && source[j] == 48; j++)
					{
						number.Scale--;
					}
				}
				int num9 = Math.Min(i - j, 51 - num - 1);
				source.Slice(j, num9).CopyTo(digits.Slice(num));
				num += num9;
				if (i == source.Length)
				{
					if (num4 == 0 && num7 == 0)
					{
						bytesConsumed = 0;
						return false;
					}
					bytesConsumed = i;
					return true;
				}
			}
			if (num4 == 0 && num7 == 0)
			{
				bytesConsumed = 0;
				return false;
			}
			if ((b & -33) != 69)
			{
				bytesConsumed = i;
				return true;
			}
			textUsedExponentNotation = true;
			i++;
			if ((options & ParseNumberOptions.AllowExponent) == 0)
			{
				bytesConsumed = 0;
				return false;
			}
			if (i == source.Length)
			{
				bytesConsumed = 0;
				return false;
			}
			bool flag = false;
			b = source[i];
			if (b != 43)
			{
				if (b != 45)
				{
					goto IL_0229;
				}
				flag = true;
			}
			i++;
			if (i == source.Length)
			{
				bytesConsumed = 0;
				return false;
			}
			b = source[i];
			goto IL_0229;
			IL_0229:
			if (!TryParseUInt32D(source.Slice(i), out var value, out var bytesConsumed2))
			{
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (flag)
			{
				if (number.Scale < int.MinValue + value)
				{
					number.Scale = int.MinValue;
				}
				else
				{
					number.Scale -= (int)value;
				}
			}
			else
			{
				if (number.Scale > 2147483647L - (long)value)
				{
					bytesConsumed = 0;
					return false;
				}
				number.Scale += (int)value;
			}
			bytesConsumed = i;
			return true;
		}

		private static bool TryParseTimeSpanBigG(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed)
		{
			int i = 0;
			byte b = 0;
			for (; i != source.Length; i++)
			{
				b = source[i];
				if (b != 32 && b != 9)
				{
					break;
				}
			}
			if (i == source.Length)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			bool isNegative = false;
			if (b == 45)
			{
				isNegative = true;
				i++;
				if (i == source.Length)
				{
					value = default(TimeSpan);
					bytesConsumed = 0;
					return false;
				}
			}
			if (!TryParseUInt32D(source.Slice(i), out var value2, out var bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 58)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32D(source.Slice(i), out var value3, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 58)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32D(source.Slice(i), out var value4, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 58)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseUInt32D(source.Slice(i), out var value5, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (i == source.Length || source[i++] != 46)
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (!TryParseTimeSpanFraction(source.Slice(i), out var value6, out bytesConsumed2))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			i += bytesConsumed2;
			if (!TryCreateTimeSpan(isNegative, value2, value3, value4, value5, value6, out value))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			if (i != source.Length && (source[i] == 46 || source[i] == 58))
			{
				value = default(TimeSpan);
				bytesConsumed = 0;
				return false;
			}
			bytesConsumed = i;
			return true;
		}

		private static bool TryParseTimeSpanC(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed)
		{
			TimeSpanSplitter timeSpanSplitter = default(TimeSpanSplitter);
			if (!timeSpanSplitter.TrySplitTimeSpan(source, periodUsedToSeparateDay: true, out bytesConsumed))
			{
				value = default(TimeSpan);
				return false;
			}
			bool isNegative = timeSpanSplitter.IsNegative;
			bool flag;
			switch (timeSpanSplitter.Separators)
			{
			case 0u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, 0u, 0u, 0u, 0u, out value);
				break;
			case 16777216u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, 0u, 0u, out value);
				break;
			case 33619968u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, 0u, 0u, out value);
				break;
			case 16842752u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, 0u, out value);
				break;
			case 33620224u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, 0u, out value);
				break;
			case 16843264u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, out value);
				break;
			case 33620226u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, timeSpanSplitter.V5, out value);
				break;
			default:
				value = default(TimeSpan);
				flag = false;
				break;
			}
			if (!flag)
			{
				bytesConsumed = 0;
				return false;
			}
			return true;
		}

		public static bool TryParse(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed, char standardFormat = '\0')
		{
			switch (standardFormat)
			{
			case '\0':
			case 'T':
			case 'c':
			case 't':
				return TryParseTimeSpanC(source, out value, out bytesConsumed);
			case 'G':
				return TryParseTimeSpanBigG(source, out value, out bytesConsumed);
			case 'g':
				return TryParseTimeSpanLittleG(source, out value, out bytesConsumed);
			default:
				return System.ThrowHelper.TryParseThrowFormatException<TimeSpan>(out value, out bytesConsumed);
			}
		}

		private static bool TryParseTimeSpanFraction(ReadOnlySpan<byte> source, out uint value, out int bytesConsumed)
		{
			int num = 0;
			if (num == source.Length)
			{
				value = 0u;
				bytesConsumed = 0;
				return false;
			}
			uint num2 = (uint)(source[num] - 48);
			if (num2 > 9)
			{
				value = 0u;
				bytesConsumed = 0;
				return false;
			}
			num++;
			uint num3 = num2;
			int num4 = 1;
			while (num != source.Length)
			{
				num2 = (uint)(source[num] - 48);
				if (num2 > 9)
				{
					break;
				}
				num++;
				num4++;
				if (num4 > 7)
				{
					value = 0u;
					bytesConsumed = 0;
					return false;
				}
				num3 = 10 * num3 + num2;
			}
			switch (num4)
			{
			case 6:
				num3 *= 10;
				break;
			case 5:
				num3 *= 100;
				break;
			case 4:
				num3 *= 1000;
				break;
			case 3:
				num3 *= 10000;
				break;
			case 2:
				num3 *= 100000;
				break;
			default:
				num3 *= 1000000;
				break;
			case 7:
				break;
			}
			value = num3;
			bytesConsumed = num;
			return true;
		}

		private static bool TryCreateTimeSpan(bool isNegative, uint days, uint hours, uint minutes, uint seconds, uint fraction, out TimeSpan timeSpan)
		{
			if (hours > 23 || minutes > 59 || seconds > 59)
			{
				timeSpan = default(TimeSpan);
				return false;
			}
			long num = ((long)days * 3600L * 24 + (long)hours * 3600L + (long)minutes * 60L + seconds) * 1000;
			long ticks;
			if (isNegative)
			{
				num = -num;
				if (num < -922337203685477L)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				long num2 = num * 10000;
				if (num2 < long.MinValue + fraction)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				ticks = num2 - fraction;
			}
			else
			{
				if (num > 922337203685477L)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				long num3 = num * 10000;
				if (num3 > long.MaxValue - (long)fraction)
				{
					timeSpan = default(TimeSpan);
					return false;
				}
				ticks = num3 + fraction;
			}
			timeSpan = new TimeSpan(ticks);
			return true;
		}

		private static bool TryParseTimeSpanLittleG(ReadOnlySpan<byte> source, out TimeSpan value, out int bytesConsumed)
		{
			TimeSpanSplitter timeSpanSplitter = default(TimeSpanSplitter);
			if (!timeSpanSplitter.TrySplitTimeSpan(source, periodUsedToSeparateDay: false, out bytesConsumed))
			{
				value = default(TimeSpan);
				return false;
			}
			bool isNegative = timeSpanSplitter.IsNegative;
			bool flag;
			switch (timeSpanSplitter.Separators)
			{
			case 0u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, 0u, 0u, 0u, 0u, out value);
				break;
			case 16777216u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, 0u, 0u, out value);
				break;
			case 16842752u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, 0u, out value);
				break;
			case 16843008u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, 0u, out value);
				break;
			case 16843264u:
				flag = TryCreateTimeSpan(isNegative, 0u, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, out value);
				break;
			case 16843010u:
				flag = TryCreateTimeSpan(isNegative, timeSpanSplitter.V1, timeSpanSplitter.V2, timeSpanSplitter.V3, timeSpanSplitter.V4, timeSpanSplitter.V5, out value);
				break;
			default:
				value = default(TimeSpan);
				flag = false;
				break;
			}
			if (!flag)
			{
				bytesConsumed = 0;
				return false;
			}
			return true;
		}
	}
}
namespace System.Buffers.Binary
{
	internal static class BinaryPrimitives
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static sbyte ReverseEndianness(sbyte value)
		{
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ReverseEndianness(short value)
		{
			return (short)(((value & 0xFF) << 8) | ((value & 0xFF00) >> 8));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ReverseEndianness(int value)
		{
			return (int)ReverseEndianness((uint)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long ReverseEndianness(long value)
		{
			return (long)ReverseEndianness((ulong)value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte ReverseEndianness(byte value)
		{
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort ReverseEndianness(ushort value)
		{
			return (ushort)((value >> 8) + (value << 8));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint ReverseEndianness(uint value)
		{
			uint num = value & 0xFF00FFu;
			uint num2 = value & 0xFF00FF00u;
			return ((num >> 8) | (num << 24)) + ((num2 << 8) | (num2 >> 24));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong ReverseEndianness(ulong value)
		{
			return ((ulong)ReverseEndianness((uint)value) << 32) + ReverseEndianness((uint)(value >> 32));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ReadInt16BigEndian(ReadOnlySpan<byte> source)
		{
			short num = MemoryMarshal.Read<short>(source);
			if (BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ReadInt32BigEndian(ReadOnlySpan<byte> source)
		{
			int num = MemoryMarshal.Read<int>(source);
			if (BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long ReadInt64BigEndian(ReadOnlySpan<byte> source)
		{
			long num = MemoryMarshal.Read<long>(source);
			if (BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort ReadUInt16BigEndian(ReadOnlySpan<byte> source)
		{
			ushort num = MemoryMarshal.Read<ushort>(source);
			if (BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint ReadUInt32BigEndian(ReadOnlySpan<byte> source)
		{
			uint num = MemoryMarshal.Read<uint>(source);
			if (BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong ReadUInt64BigEndian(ReadOnlySpan<byte> source)
		{
			ulong num = MemoryMarshal.Read<ulong>(source);
			if (BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt16BigEndian(ReadOnlySpan<byte> source, out short value)
		{
			bool result = MemoryMarshal.TryRead<short>(source, out value);
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt32BigEndian(ReadOnlySpan<byte> source, out int value)
		{
			bool result = MemoryMarshal.TryRead<int>(source, out value);
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt64BigEndian(ReadOnlySpan<byte> source, out long value)
		{
			bool result = MemoryMarshal.TryRead<long>(source, out value);
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt16BigEndian(ReadOnlySpan<byte> source, out ushort value)
		{
			bool result = MemoryMarshal.TryRead<ushort>(source, out value);
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt32BigEndian(ReadOnlySpan<byte> source, out uint value)
		{
			bool result = MemoryMarshal.TryRead<uint>(source, out value);
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt64BigEndian(ReadOnlySpan<byte> source, out ulong value)
		{
			bool result = MemoryMarshal.TryRead<ulong>(source, out value);
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static short ReadInt16LittleEndian(ReadOnlySpan<byte> source)
		{
			short num = MemoryMarshal.Read<short>(source);
			if (!BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int ReadInt32LittleEndian(ReadOnlySpan<byte> source)
		{
			int num = MemoryMarshal.Read<int>(source);
			if (!BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static long ReadInt64LittleEndian(ReadOnlySpan<byte> source)
		{
			long num = MemoryMarshal.Read<long>(source);
			if (!BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ushort ReadUInt16LittleEndian(ReadOnlySpan<byte> source)
		{
			ushort num = MemoryMarshal.Read<ushort>(source);
			if (!BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static uint ReadUInt32LittleEndian(ReadOnlySpan<byte> source)
		{
			uint num = MemoryMarshal.Read<uint>(source);
			if (!BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static ulong ReadUInt64LittleEndian(ReadOnlySpan<byte> source)
		{
			ulong num = MemoryMarshal.Read<ulong>(source);
			if (!BitConverter.IsLittleEndian)
			{
				num = ReverseEndianness(num);
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt16LittleEndian(ReadOnlySpan<byte> source, out short value)
		{
			bool result = MemoryMarshal.TryRead<short>(source, out value);
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt32LittleEndian(ReadOnlySpan<byte> source, out int value)
		{
			bool result = MemoryMarshal.TryRead<int>(source, out value);
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryReadInt64LittleEndian(ReadOnlySpan<byte> source, out long value)
		{
			bool result = MemoryMarshal.TryRead<long>(source, out value);
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt16LittleEndian(ReadOnlySpan<byte> source, out ushort value)
		{
			bool result = MemoryMarshal.TryRead<ushort>(source, out value);
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt32LittleEndian(ReadOnlySpan<byte> source, out uint value)
		{
			bool result = MemoryMarshal.TryRead<uint>(source, out value);
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryReadUInt64LittleEndian(ReadOnlySpan<byte> source, out ulong value)
		{
			bool result = MemoryMarshal.TryRead<ulong>(source, out value);
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return result;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt16BigEndian(Span<byte> destination, short value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt32BigEndian(Span<byte> destination, int value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt64BigEndian(Span<byte> destination, long value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt16BigEndian(Span<byte> destination, ushort value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt32BigEndian(Span<byte> destination, uint value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt64BigEndian(Span<byte> destination, ulong value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt16BigEndian(Span<byte> destination, short value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt32BigEndian(Span<byte> destination, int value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt64BigEndian(Span<byte> destination, long value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt16BigEndian(Span<byte> destination, ushort value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt32BigEndian(Span<byte> destination, uint value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt64BigEndian(Span<byte> destination, ulong value)
		{
			if (BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt16LittleEndian(Span<byte> destination, short value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt32LittleEndian(Span<byte> destination, int value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt64LittleEndian(Span<byte> destination, long value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt16LittleEndian(Span<byte> destination, ushort value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt32LittleEndian(Span<byte> destination, uint value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static void WriteUInt64LittleEndian(Span<byte> destination, ulong value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			MemoryMarshal.Write(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt16LittleEndian(Span<byte> destination, short value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt32LittleEndian(Span<byte> destination, int value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool TryWriteInt64LittleEndian(Span<byte> destination, long value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt16LittleEndian(Span<byte> destination, ushort value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt32LittleEndian(Span<byte> destination, uint value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[CLSCompliant(false)]
		public static bool TryWriteUInt64LittleEndian(Span<byte> destination, ulong value)
		{
			if (!BitConverter.IsLittleEndian)
			{
				value = ReverseEndianness(value);
			}
			return MemoryMarshal.TryWrite(destination, ref value);
		}
	}
}
[CompilerGenerated]
internal sealed class <b9591c5d-2209-4e61-9a7e-6aac8296b1ea><PrivateImplementationDetails>
{
	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 15)]
	private struct __StaticArrayInitTypeSize=15
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 28)]
	private struct __StaticArrayInitTypeSize=28
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 42)]
	private struct __StaticArrayInitTypeSize=42
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 48)]
	private struct __StaticArrayInitTypeSize=48
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 52)]
	private struct __StaticArrayInitTypeSize=52
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 64)]
	private struct __StaticArrayInitTypeSize=64
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 240)]
	private struct __StaticArrayInitTypeSize=240
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 256)]
	private struct __StaticArrayInitTypeSize=256
	{
	}

	[StructLayout(LayoutKind.Explicit, Pack = 1, Size = 336)]
	private struct __StaticArrayInitTypeSize=336
	{
	}

	internal static readonly __StaticArrayInitTypeSize=64 0953DF544832295E4A5B19928F95C351F25DA86A/* Not supported: data(41 42 43 44 45 46 47 48 49 4A 4B 4C 4D 4E 4F 50 51 52 53 54 55 56 57 58 59 5A 61 62 63 64 65 66 67 68 69 6A 6B 6C 6D 6E 6F 70 71 72 73 74 75 76 77 78 79 7A 30 31 32 33 34 35 36 37 38 39 2B 2F) */;

	internal static readonly __StaticArrayInitTypeSize=256 1588174EA926BCCEB6275C029A42C7E3DBA4D523/* Not supported: data(FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 3E FF FF FF 3F 34 35 36 37 38 39 3A 3B 3C 3D FF FF FF FF FF FF FF 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 FF FF FF FF FF FF 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF) */;

	internal static readonly __StaticArrayInitTypeSize=336 2B2055E39CBB1C111FB5C1C05492B3E5AAC607ED/* Not supported: data(00 00 00 04 BF C9 1B 8E 9E B5 70 2B A8 AD C5 9D D6 95 43 0E 05 8D 29 AF D4 A6 CF FF 49 1F 78 C2 FA F7 DA 87 8F 7A E7 D7 A0 14 9B C5 16 AB B3 EF 9C 32 23 99 C0 AD 0F 85 DE 8C E9 80 C9 47 BA 93 E6 A6 D3 A8 C5 B9 02 A4 A8 17 E6 7F 2B A1 16 B6 90 BF 9B 85 91 A2 28 CA 66 55 27 39 8D F7 70 E0 40 61 82 37 35 0C 2E F9 2C C9 3C E3 FF 96 52 8A 62 17 BF D6 F3 A6 91 99 8A DE F9 9D FB EB 7E AA 7E BC 9D A7 4A D1 49 BD 88 2F 6A 5C 19 FC 26 D2 F8 83 7C 24 20 DF 50 E9 73 E3 CC F2 29 2F 84 81 E2 E4 8E 55 57 C2 CA 8F 60 E1 4D C4 BE 94 95 E6 C3 94 39 45 AD 1E B1 CF 65 C1 7E B1 53 7C 12 BB B3 E9 39 A5 27 EA 7F A8 B5 19 09 6B BA 60 C5 97 AB 53 75 FD F7 02 B4 88 A0 D3 65 F0 BC 35 43 F6 C4 E4 BC 64 7C 46 D0 DD ED 82 53 7C 6E BA CA C7 B7 A0 73 DB 93 E0 F4 B3 53 00 CB 38 DB 27 17 A2 29 CC 23 54 77 83 FF 91 82 BC A4 3D A9 DE 80 83 00 4F 31 4A EC 3C E5 EC 17 E2 32 CF CD 5F 60 D5 78 19 7A 63 25 43 31 C0 A2 3B E4 5E AB 8E 1C AD B0 C5 6A 83 62 CE EC 9B 5C 49 0B BA D9 DC 71 8C 38 39 82 47 97 B8 00 FD 1A 99 8D 4D 44 7A E2 E3) */;

	internal static readonly __StaticArrayInitTypeSize=256 3CDA7449B0586AB873C75C04BB11D4864F5D7392/* Not supported: data(FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 00 01 02 03 04 05 06 07 08 09 FF FF FF FF FF FF FF 0A 0B 0C 0D 0E 0F FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF 0A 0B 0C 0D 0E 0F FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF FF) */;

	internal static readonly __StaticArrayInitTypeSize=240 608454F961E288A48E34666C94032BEDEFD399E1/* Not supported: data(00 00 00 00 00 00 00 A0 00 00 00 00 00 00 00 C8 00 00 00 00 00 00 00 FA 00 00 00 00 00 00 40 9C 00 00 00 00 00 00 50 C3 00 00 00 00 00 00 24 F4 00 00 00 00 00 80 96 98 00 00 00 00 00 20 BC BE 00 00 00 00 00 28 6B EE 00 00 00 00 00 F9 02 95 00 00 00 00 40 B7 43 BA 00 00 00 00 10 A5 D4 E8 00 00 00 00 2A E7 84 91 00 00 00 80 F4 20 E6 B5 00 00 00 A0 31 A9 5F E3 CD CC CC CC CC CC CC CC 0B D7 A3 70 3D 0A D7 A3 3C DF 4F 8D 97 6E 12 83 2E 65 19 E2 58 17 B7 D1 25 84 47 1B 47 AC C5 A7 B7 69 6C AF 05 BD 37 86 BE 42 7A E5 D5 94 BF D6 FF CE 61 84 11 77 CC AB 99 A5 B4 36 41 5F 70 89 C2 D5 ED BD CE FE E6 DB 02 AB 24 CB 0B FF EB AF CF 88 50 6F 09 CC BC 8C 18 0E B4 4B 42 13 2E E1 13 D8 5C 09 35 DC 24 B4 DC AC B0 3A F7 7C 1D 90) */;

	internal static readonly __StaticArrayInitTypeSize=48 B8B960BE929E7BAB90AE2CAEF2468C56CD5414C1/* Not supported: data(6A 61 6E 00 66 65 62 00 6D 61 72 00 61 70 72 00 6D 61 79 00 6A 75 6E 00 6A 75 6C 00 61 75 67 00 73 65 70 00 6F 63 74 00 6E 6F 76 00 64 65 63 00) */;

	internal static readonly __StaticArrayInitTypeSize=28 BD20BFA840DDF83194ECD4397DA071ECD4C1C72F/* Not supported: data(53 75 6E 00 4D 6F 6E 00 54 75 65 00 57 65 64 00 54 68 75 00 46 72 69 00 53 61 74 00) */;

	internal static readonly __StaticArrayInitTypeSize=15 C3FB1115E83603E7E71244A6F2D43E22B790B5D1/* Not supported: data(04 07 0A 0E 11 14 18 1B 1E 22 25 28 2C 2F 32) */;

	internal static readonly __StaticArrayInitTypeSize=48 C4C38BC485A320D4B7D737DB85E705077FA38BEF/* Not supported: data(4A 61 6E 00 46 65 62 00 4D 61 72 00 41 70 72 00 4D 61 79 00 4A 75 6E 00 4A 75 6C 00 41 75 67 00 53 65 70 00 4F 63 74 00 4E 6F 76 00 44 65 63 00) */;

	internal static readonly __StaticArrayInitTypeSize=42 DB5930245CE35BDE5EDC35035275D8DD55E139CF/* Not supported: data(36 00 6B 00 A0 00 D5 00 0A 01 3F 01 75 01 AA 01 DF 01 14 02 49 02 7E 02 B3 02 E9 02 1E 03 53 03 88 03 BD 03 F2 03 28 04 5D 04) */;

	internal static readonly __StaticArrayInitTypeSize=52 DD3AEFEADB1CD615F3017763F1568179FEE640B0/* Not supported: data(00 00 00 00 1F 00 00 00 3C 00 00 00 5B 00 00 00 79 00 00 00 98 00 00 00 B6 00 00 00 D5 00 00 00 F4 00 00 00 12 01 00 00 31 01 00 00 4F 01 00 00 6E 01 00 00) */;

	internal static readonly __StaticArrayInitTypeSize=52 E92B39D8233061927D9ACDE54665E68E7535635A/* Not supported: data(00 00 00 00 1F 00 00 00 3B 00 00 00 5A 00 00 00 78 00 00 00 97 00 00 00 B5 00 00 00 D4 00 00 00 F3 00 00 00 11 01 00 00 30 01 00 00 4E 01 00 00 6D 01 00 00) */;

	internal static readonly __StaticArrayInitTypeSize=28 EE0B1C00D481FCA3559F2937C3DD3127C35B2FE3/* Not supported: data(73 75 6E 00 6D 6F 6E 00 74 75 65 00 77 65 64 00 74 68 75 00 66 72 69 00 73 61 74 00) */;
}
namespace Microsoft.CodeAnalysis
{
	[<3e759243-32c9-41fc-8df7-f593ee205431>Embedded]
	[CompilerGenerated]
	internal sealed class <3e759243-32c9-41fc-8df7-f593ee205431>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<3e759243-32c9-41fc-8df7-f593ee205431>Embedded]
	[CompilerGenerated]
	internal sealed class <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnlyAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<3e759243-32c9-41fc-8df7-f593ee205431>Embedded]
	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]
	[<3e759243-32c9-41fc-8df7-f593ee205431>Embedded]
	[AttributeUsage(AttributeTargets.Module | 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;
		}
	}
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	[CompilerGenerated]
	[<3e759243-32c9-41fc-8df7-f593ee205431>Embedded]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
}
namespace FxResources.System.Collections.Immutable
{
	internal static class SR
	{
	}
}
namespace System
{
	internal static class SR
	{
		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(typeof(FxResources.System.Collections.Immutable.SR)));

		internal static string Arg_KeyNotFoundWithKey => GetResourceString("Arg_KeyNotFoundWithKey");

		internal static string ArrayInitializedStateNotEqual => GetResourceString("ArrayInitializedStateNotEqual");

		internal static string ArrayLengthsNotEqual => GetResourceString("ArrayLengthsNotEqual");

		internal static string CannotFindOldValue => GetResourceString("CannotFindOldValue");

		internal static string CapacityMustBeGreaterThanOrEqualToCount => GetResourceString("CapacityMustBeGreaterThanOrEqualToCount");

		internal static string CapacityMustEqualCountOnMove => GetResourceString("CapacityMustEqualCountOnMove");

		internal static string CollectionModifiedDuringEnumeration => GetResourceString("CollectionModifiedDuringEnumeration");

		internal static string DuplicateKey => GetResourceString("DuplicateKey");

		internal static string InvalidEmptyOperation => GetResourceString("InvalidEmptyOperation");

		internal static string InvalidOperationOnDefaultArray => GetResourceString("InvalidOperationOnDefaultArray");

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static bool UsingResourceKeys()
		{
			return false;
		}

		internal static string GetResourceString(string resourceKey, string? defaultString = null)
		{
			if (UsingResourceKeys())
			{
				return defaultString ?? resourceKey;
			}
			string text = null;
			try
			{
				text = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			if (defaultString != null && resourceKey.Equals(text))
			{
				return defaultString;
			}
			return text;
		}

		internal static string Format(string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}

		internal static string Format(string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(provider, resourceFormat, p1);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(provider, resourceFormat, p1, p2);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, object? p1, object? p2, object? p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(provider, resourceFormat, p1, p2, p3);
		}

		internal static string Format(IFormatProvider? provider, string resourceFormat, params object?[]? args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(provider, resourceFormat, args);
			}
			return resourceFormat;
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class <697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionableAttribute : Attribute
	{
	}
}
namespace System.Linq
{
	internal static class ImmutableArrayExtensions
	{
		public static IEnumerable<TResult> Select<T, TResult>(this ImmutableArray<T> immutableArray, Func<T, TResult> selector)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.Select(selector);
		}

		public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this ImmutableArray<TSource> immutableArray, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			if (collectionSelector == null || resultSelector == null)
			{
				return Enumerable.SelectMany(immutableArray, collectionSelector, resultSelector);
			}
			if (immutableArray.Length != 0)
			{
				return immutableArray.SelectManyIterator(collectionSelector, resultSelector);
			}
			return Enumerable.Empty<TResult>();
		}

		public static IEnumerable<T> Where<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.Where(predicate);
		}

		public static bool Any<T>(this ImmutableArray<T> immutableArray)
		{
			return immutableArray.Length > 0;
		}

		public static bool Any<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				if (predicate(arg))
				{
					return true;
				}
			}
			return false;
		}

		public static bool All<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				if (!predicate(arg))
				{
					return false;
				}
			}
			return true;
		}

		public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> immutableArray, ImmutableArray<TDerived> items, IEqualityComparer<TBase> comparer = null) where TDerived : TBase
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			items.ThrowNullRefIfNotInitialized();
			if (immutableArray.array == items.array)
			{
				return true;
			}
			if (immutableArray.Length != items.Length)
			{
				return false;
			}
			if (comparer == null)
			{
				comparer = EqualityComparer<TBase>.Default;
			}
			for (int i = 0; i < immutableArray.Length; i++)
			{
				if (!comparer.Equals(immutableArray.array[i], (TBase)(object)items.array[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> immutableArray, IEnumerable<TDerived> items, IEqualityComparer<TBase> comparer = null) where TDerived : TBase
		{
			Requires.NotNull(items, "items");
			if (comparer == null)
			{
				comparer = EqualityComparer<TBase>.Default;
			}
			int num = 0;
			int length = immutableArray.Length;
			foreach (TDerived item in items)
			{
				if (num == length)
				{
					return false;
				}
				if (!comparer.Equals(immutableArray[num], (TBase)(object)item))
				{
					return false;
				}
				num++;
			}
			return num == length;
		}

		public static bool SequenceEqual<TDerived, TBase>(this ImmutableArray<TBase> immutableArray, ImmutableArray<TDerived> items, Func<TBase, TBase, bool> predicate) where TDerived : TBase
		{
			Requires.NotNull(predicate, "predicate");
			immutableArray.ThrowNullRefIfNotInitialized();
			items.ThrowNullRefIfNotInitialized();
			if (immutableArray.array == items.array)
			{
				return true;
			}
			if (immutableArray.Length != items.Length)
			{
				return false;
			}
			int i = 0;
			for (int length = immutableArray.Length; i < length; i++)
			{
				if (!predicate(immutableArray[i], (TBase)(object)items[i]))
				{
					return false;
				}
			}
			return true;
		}

		public static T Aggregate<T>(this ImmutableArray<T> immutableArray, Func<T, T, T> func)
		{
			Requires.NotNull(func, "func");
			if (immutableArray.Length == 0)
			{
				return default(T);
			}
			T val = immutableArray[0];
			int i = 1;
			for (int length = immutableArray.Length; i < length; i++)
			{
				val = func(val, immutableArray[i]);
			}
			return val;
		}

		public static TAccumulate Aggregate<TAccumulate, T>(this ImmutableArray<T> immutableArray, TAccumulate seed, Func<TAccumulate, T, TAccumulate> func)
		{
			Requires.NotNull(func, "func");
			TAccumulate val = seed;
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				val = func(val, arg);
			}
			return val;
		}

		public static TResult Aggregate<TAccumulate, TResult, T>(this ImmutableArray<T> immutableArray, TAccumulate seed, Func<TAccumulate, T, TAccumulate> func, Func<TAccumulate, TResult> resultSelector)
		{
			Requires.NotNull(resultSelector, "resultSelector");
			return resultSelector(immutableArray.Aggregate(seed, func));
		}

		public static T ElementAt<T>(this ImmutableArray<T> immutableArray, int index)
		{
			return immutableArray[index];
		}

		public static T ElementAtOrDefault<T>(this ImmutableArray<T> immutableArray, int index)
		{
			if (index < 0 || index >= immutableArray.Length)
			{
				return default(T);
			}
			return immutableArray[index];
		}

		public static T First<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					return val;
				}
			}
			return Enumerable.Empty<T>().First();
		}

		public static T First<T>(this ImmutableArray<T> immutableArray)
		{
			if (immutableArray.Length <= 0)
			{
				return immutableArray.array.First();
			}
			return immutableArray[0];
		}

		public static T FirstOrDefault<T>(this ImmutableArray<T> immutableArray)
		{
			if (immutableArray.array.Length == 0)
			{
				return default(T);
			}
			return immutableArray.array[0];
		}

		public static T FirstOrDefault<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					return val;
				}
			}
			return default(T);
		}

		public static T Last<T>(this ImmutableArray<T> immutableArray)
		{
			if (immutableArray.Length <= 0)
			{
				return immutableArray.array.Last();
			}
			return immutableArray[immutableArray.Length - 1];
		}

		public static T Last<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			for (int num = immutableArray.Length - 1; num >= 0; num--)
			{
				if (predicate(immutableArray[num]))
				{
					return immutableArray[num];
				}
			}
			return Enumerable.Empty<T>().Last();
		}

		public static T LastOrDefault<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.LastOrDefault();
		}

		public static T LastOrDefault<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			for (int num = immutableArray.Length - 1; num >= 0; num--)
			{
				if (predicate(immutableArray[num]))
				{
					return immutableArray[num];
				}
			}
			return default(T);
		}

		public static T Single<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.Single();
		}

		public static T Single<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			bool flag = true;
			T result = default(T);
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					if (!flag)
					{
						ImmutableArray.TwoElementArray.Single();
					}
					flag = false;
					result = val;
				}
			}
			if (flag)
			{
				Enumerable.Empty<T>().Single();
			}
			return result;
		}

		public static T SingleOrDefault<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			return immutableArray.array.SingleOrDefault();
		}

		public static T SingleOrDefault<T>(this ImmutableArray<T> immutableArray, Func<T, bool> predicate)
		{
			Requires.NotNull(predicate, "predicate");
			bool flag = true;
			T result = default(T);
			T[] array = immutableArray.array;
			foreach (T val in array)
			{
				if (predicate(val))
				{
					if (!flag)
					{
						ImmutableArray.TwoElementArray.Single();
					}
					flag = false;
					result = val;
				}
			}
			return result;
		}

		public static Dictionary<TKey, T> ToDictionary<TKey, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector)
		{
			return immutableArray.ToDictionary(keySelector, EqualityComparer<TKey>.Default);
		}

		public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector, Func<T, TElement> elementSelector)
		{
			return immutableArray.ToDictionary(keySelector, elementSelector, EqualityComparer<TKey>.Default);
		}

		public static Dictionary<TKey, T> ToDictionary<TKey, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector, IEqualityComparer<TKey> comparer)
		{
			Requires.NotNull(keySelector, "keySelector");
			Dictionary<TKey, T> dictionary = new Dictionary<TKey, T>(immutableArray.Length, comparer);
			ImmutableArray<T>.Enumerator enumerator = immutableArray.GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				dictionary.Add(keySelector(current), current);
			}
			return dictionary;
		}

		public static Dictionary<TKey, TElement> ToDictionary<TKey, TElement, T>(this ImmutableArray<T> immutableArray, Func<T, TKey> keySelector, Func<T, TElement> elementSelector, IEqualityComparer<TKey> comparer)
		{
			Requires.NotNull(keySelector, "keySelector");
			Requires.NotNull(elementSelector, "elementSelector");
			Dictionary<TKey, TElement> dictionary = new Dictionary<TKey, TElement>(immutableArray.Length, comparer);
			T[] array = immutableArray.array;
			foreach (T arg in array)
			{
				dictionary.Add(keySelector(arg), elementSelector(arg));
			}
			return dictionary;
		}

		public static T[] ToArray<T>(this ImmutableArray<T> immutableArray)
		{
			immutableArray.ThrowNullRefIfNotInitialized();
			if (immutableArray.array.Length == 0)
			{
				return ImmutableArray<T>.Empty.array;
			}
			return (T[])immutableArray.array.Clone();
		}

		public static T First<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				throw new InvalidOperationException();
			}
			return builder[0];
		}

		public static T FirstOrDefault<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				return default(T);
			}
			return builder[0];
		}

		public static T Last<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				throw new InvalidOperationException();
			}
			return builder[builder.Count - 1];
		}

		public static T LastOrDefault<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			if (!builder.Any())
			{
				return default(T);
			}
			return builder[builder.Count - 1];
		}

		public static bool Any<T>(this ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.Count > 0;
		}

		private static IEnumerable<TResult> SelectManyIterator<TSource, TCollection, TResult>(this ImmutableArray<TSource> immutableArray, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector)
		{
			TSource[] array = immutableArray.array;
			foreach (TSource item in array)
			{
				foreach (TCollection item2 in collectionSelector(item))
				{
					yield return resultSelector(item, item2);
				}
			}
		}
	}
}
namespace System.Collections.Immutable
{
	internal static class AllocFreeConcurrentStack<T>
	{
		private const int MaxSize = 35;

		private static readonly Type s_typeOfT = typeof(T);

		private static Stack<RefAsValueType<T>> ThreadLocalStack
		{
			get
			{
				Dictionary<Type, object> dictionary = AllocFreeConcurrentStack.t_stacks;
				if (dictionary == null)
				{
					dictionary = (AllocFreeConcurrentStack.t_stacks = new Dictionary<Type, object>());
				}
				if (!dictionary.TryGetValue(s_typeOfT, out var value))
				{
					value = new Stack<RefAsValueType<T>>(35);
					dictionary.Add(s_typeOfT, value);
				}
				return (Stack<RefAsValueType<T>>)value;
			}
		}

		public static void TryAdd(T item)
		{
			Stack<RefAsValueType<T>> threadLocalStack = ThreadLocalStack;
			if (threadLocalStack.Count < 35)
			{
				threadLocalStack.Push(new RefAsValueType<T>(item));
			}
		}

		public static bool TryTake(out T item)
		{
			Stack<RefAsValueType<T>> threadLocalStack = ThreadLocalStack;
			if (threadLocalStack != null && threadLocalStack.Count > 0)
			{
				item = threadLocalStack.Pop().Value;
				return true;
			}
			item = default(T);
			return false;
		}
	}
	internal static class AllocFreeConcurrentStack
	{
		[ThreadStatic]
		internal static Dictionary<Type, object> t_stacks;
	}
	internal sealed class DictionaryEnumerator<TKey, TValue> : IDictionaryEnumerator, IEnumerator
	{
		private readonly IEnumerator<KeyValuePair<TKey, TValue>> _inner;

		public DictionaryEntry Entry => new DictionaryEntry(_inner.Current.Key, _inner.Current.Value);

		public object Key => _inner.Current.Key;

		public object Value => _inner.Current.Value;

		public object Current => Entry;

		internal DictionaryEnumerator(IEnumerator<KeyValuePair<TKey, TValue>> inner)
		{
			Requires.NotNull(inner, "inner");
			_inner = inner;
		}

		public bool MoveNext()
		{
			return _inner.MoveNext();
		}

		public void Reset()
		{
			_inner.Reset();
		}
	}
	internal struct DisposableEnumeratorAdapter<T, TEnumerator> : IDisposable where TEnumerator : struct, IEnumerator<T>
	{
		private readonly IEnumerator<T> _enumeratorObject;

		private TEnumerator _enumeratorStruct;

		public T Current
		{
			get
			{
				if (_enumeratorObject == null)
				{
					return _enumeratorStruct.Current;
				}
				return _enumeratorObject.Current;
			}
		}

		internal DisposableEnumeratorAdapter(TEnumerator enumerator)
		{
			_enumeratorStruct = enumerator;
			_enumeratorObject = null;
		}

		internal DisposableEnumeratorAdapter(IEnumerator<T> enumerator)
		{
			_enumeratorStruct = default(TEnumerator);
			_enumeratorObject = enumerator;
		}

		public bool MoveNext()
		{
			if (_enumeratorObject == null)
			{
				return _enumeratorStruct.MoveNext();
			}
			return _enumeratorObject.MoveNext();
		}

		public void Dispose()
		{
			if (_enumeratorObject != null)
			{
				_enumeratorObject.Dispose();
			}
			else
			{
				_enumeratorStruct.Dispose();
			}
		}

		public DisposableEnumeratorAdapter<T, TEnumerator> GetEnumerator()
		{
			return this;
		}
	}
	internal interface IBinaryTree
	{
		int Height { get; }

		bool IsEmpty { get; }

		int Count { get; }

		IBinaryTree Left { get; }

		IBinaryTree Right { get; }
	}
	internal interface IBinaryTree<out T> : IBinaryTree
	{
		T Value { get; }

		new IBinaryTree<T> Left { get; }

		new IBinaryTree<T> Right { get; }
	}
	internal interface IImmutableArray
	{
		Array Array { get; }
	}
	internal interface IImmutableDictionary<TKey, TValue> : IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
	{
		IImmutableDictionary<TKey, TValue> Clear();

		IImmutableDictionary<TKey, TValue> Add(TKey key, TValue value);

		IImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs);

		IImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value);

		IImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items);

		IImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys);

		IImmutableDictionary<TKey, TValue> Remove(TKey key);

		bool Contains(KeyValuePair<TKey, TValue> pair);

		bool TryGetKey(TKey equalKey, out TKey actualKey);
	}
	internal interface IImmutableDictionaryInternal<TKey, TValue>
	{
		bool ContainsValue(TValue value);
	}
	internal interface IImmutableList<T> : IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable
	{
		IImmutableList<T> Clear();

		int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);

		int LastIndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer);

		IImmutableList<T> Add(T value);

		IImmutableList<T> AddRange(IEnumerable<T> items);

		IImmutableList<T> Insert(int index, T element);

		IImmutableList<T> InsertRange(int index, IEnumerable<T> items);

		IImmutableList<T> Remove(T value, IEqualityComparer<T> equalityComparer);

		IImmutableList<T> RemoveAll(Predicate<T> match);

		IImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer);

		IImmutableList<T> RemoveRange(int index, int count);

		IImmutableList<T> RemoveAt(int index);

		IImmutableList<T> SetItem(int index, T value);

		IImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer);
	}
	internal interface IImmutableListQueries<T> : IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable
	{
		ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter);

		void ForEach(Action<T> action);

		ImmutableList<T> GetRange(int index, int count);

		void CopyTo(T[] array);

		void CopyTo(T[] array, int arrayIndex);

		void CopyTo(int index, T[] array, int arrayIndex, int count);

		bool Exists(Predicate<T> match);

		T Find(Predicate<T> match);

		ImmutableList<T> FindAll(Predicate<T> match);

		int FindIndex(Predicate<T> match);

		int FindIndex(int startIndex, Predicate<T> match);

		int FindIndex(int startIndex, int count, Predicate<T> match);

		T FindLast(Predicate<T> match);

		int FindLastIndex(Predicate<T> match);

		int FindLastIndex(int startIndex, Predicate<T> match);

		int FindLastIndex(int startIndex, int count, Predicate<T> match);

		bool TrueForAll(Predicate<T> match);

		int BinarySearch(T item);

		int BinarySearch(T item, IComparer<T> comparer);

		int BinarySearch(int index, int count, T item, IComparer<T> comparer);
	}
	internal interface IImmutableQueue<T> : IEnumerable<T>, IEnumerable
	{
		bool IsEmpty { get; }

		IImmutableQueue<T> Clear();

		T Peek();

		IImmutableQueue<T> Enqueue(T value);

		IImmutableQueue<T> Dequeue();
	}
	internal interface IImmutableSet<T> : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable
	{
		IImmutableSet<T> Clear();

		bool Contains(T value);

		IImmutableSet<T> Add(T value);

		IImmutableSet<T> Remove(T value);

		bool TryGetValue(T equalValue, out T actualValue);

		IImmutableSet<T> Intersect(IEnumerable<T> other);

		IImmutableSet<T> Except(IEnumerable<T> other);

		IImmutableSet<T> SymmetricExcept(IEnumerable<T> other);

		IImmutableSet<T> Union(IEnumerable<T> other);

		bool SetEquals(IEnumerable<T> other);

		bool IsProperSubsetOf(IEnumerable<T> other);

		bool IsProperSupersetOf(IEnumerable<T> other);

		bool IsSubsetOf(IEnumerable<T> other);

		bool IsSupersetOf(IEnumerable<T> other);

		bool Overlaps(IEnumerable<T> other);
	}
	internal interface IImmutableStack<T> : IEnumerable<T>, IEnumerable
	{
		bool IsEmpty { get; }

		IImmutableStack<T> Clear();

		IImmutableStack<T> Push(T value);

		IImmutableStack<T> Pop();

		T Peek();
	}
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	[DebuggerDisplay("Count = {Count}")]
	internal sealed class ImmutableHashSet<T> : IImmutableSet<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IHashKeyCollection<T>, ICollection<T>, ISet<T>, ICollection, IStrongEnumerable<T, ImmutableHashSet<T>.Enumerator>
	{
		private class HashBucketByValueEqualityComparer : IEqualityComparer<HashBucket>
		{
			private static readonly IEqualityComparer<HashBucket> s_defaultInstance = new HashBucketByValueEqualityComparer(EqualityComparer<T>.Default);

			private readonly IEqualityComparer<T> _valueComparer;

			internal static IEqualityComparer<HashBucket> DefaultInstance => s_defaultInstance;

			internal HashBucketByValueEqualityComparer(IEqualityComparer<T> valueComparer)
			{
				Requires.NotNull(valueComparer, "valueComparer");
				_valueComparer = valueComparer;
			}

			public bool Equals(HashBucket x, HashBucket y)
			{
				return x.EqualsByValue(y, _valueComparer);
			}

			public int GetHashCode(HashBucket obj)
			{
				throw new NotSupportedException();
			}
		}

		private class HashBucketByRefEqualityComparer : IEqualityComparer<HashBucket>
		{
			private static readonly IEqualityComparer<HashBucket> s_defaultInstance = new HashBucketByRefEqualityComparer();

			internal static IEqualityComparer<HashBucket> DefaultInstance => s_defaultInstance;

			private HashBucketByRefEqualityComparer()
			{
			}

			public bool Equals(HashBucket x, HashBucket y)
			{
				return x.EqualsByRef(y);
			}

			public int GetHashCode(HashBucket obj)
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerDisplay("Count = {Count}")]
		public sealed class Builder : IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, ISet<T>, ICollection<T>
		{
			private SortedInt32KeyNode<HashBucket> _root = SortedInt32KeyNode<HashBucket>.EmptyNode;

			private IEqualityComparer<T> _equalityComparer;

			private IEqualityComparer<HashBucket> _hashBucketEqualityComparer;

			private int _count;

			private ImmutableHashSet<T> _immutable;

			private int _version;

			public int Count => _count;

			bool ICollection<T>.IsReadOnly => false;

			public IEqualityComparer<T> KeyComparer
			{
				get
				{
					return _equalityComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != _equalityComparer)
					{
						MutationResult mutationResult = ImmutableHashSet<T>.Union((IEnumerable<T>)this, new MutationInput(SortedInt32KeyNode<HashBucket>.EmptyNode, value, _hashBucketEqualityComparer, 0));
						_immutable = null;
						_equalityComparer = value;
						Root = mutationResult.Root;
						_count = mutationResult.Count;
					}
				}
			}

			internal int Version => _version;

			private MutationInput Origin => new MutationInput(Root, _equalityComparer, _hashBucketEqualityComparer, _count);

			private SortedInt32KeyNode<HashBucket> Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			internal Builder(ImmutableHashSet<T> set)
			{
				Requires.NotNull(set, "set");
				_root = set._root;
				_count = set._count;
				_equalityComparer = set._equalityComparer;
				_hashBucketEqualityComparer = set._hashBucketEqualityComparer;
				_immutable = set;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_root, this);
			}

			public ImmutableHashSet<T> ToImmutable()
			{
				if (_immutable == null)
				{
					_immutable = ImmutableHashSet<T>.Wrap(_root, _equalityComparer, _count);
				}
				return _immutable;
			}

			public bool Add(T item)
			{
				MutationResult result = ImmutableHashSet<T>.Add(item, Origin);
				Apply(result);
				return result.Count != 0;
			}

			public bool Remove(T item)
			{
				MutationResult result = ImmutableHashSet<T>.Remove(item, Origin);
				Apply(result);
				return result.Count != 0;
			}

			public bool Contains(T item)
			{
				return ImmutableHashSet<T>.Contains(item, Origin);
			}

			public void Clear()
			{
				_count = 0;
				Root = SortedInt32KeyNode<HashBucket>.EmptyNode;
			}

			public void ExceptWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.Except(other, _equalityComparer, _hashBucketEqualityComparer, _root);
				Apply(result);
			}

			public void IntersectWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.Intersect(other, Origin);
				Apply(result);
			}

			public bool IsProperSubsetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsProperSubsetOf(other, Origin);
			}

			public bool IsProperSupersetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsProperSupersetOf(other, Origin);
			}

			public bool IsSubsetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsSubsetOf(other, Origin);
			}

			public bool IsSupersetOf(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.IsSupersetOf(other, Origin);
			}

			public bool Overlaps(IEnumerable<T> other)
			{
				return ImmutableHashSet<T>.Overlaps(other, Origin);
			}

			public bool SetEquals(IEnumerable<T> other)
			{
				if (this == other)
				{
					return true;
				}
				return ImmutableHashSet<T>.SetEquals(other, Origin);
			}

			public void SymmetricExceptWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.SymmetricExcept(other, Origin);
				Apply(result);
			}

			public void UnionWith(IEnumerable<T> other)
			{
				MutationResult result = ImmutableHashSet<T>.Union(other, Origin);
				Apply(result);
			}

			void ICollection<T>.Add(T item)
			{
				Add(item);
			}

			void ICollection<T>.CopyTo(T[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

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

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private void Apply(MutationResult result)
			{
				Root = result.Root;
				if (result.CountType == CountType.Adjustment)
				{
					_count += result.Count;
				}
				else
				{
					_count = result.Count;
				}
			}
		}

		public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator, IStrongEnumerator<T>
		{
			private readonly Builder _builder;

			private SortedInt32KeyNode<HashBucket>.Enumerator _mapEnumerator;

			private HashBucket.Enumerator _bucketEnumerator;

			private int _enumeratingBuilderVersion;

			public T Current
			{
				get
				{
					_mapEnumerator.ThrowIfDisposed();
					return _bucketEnumerator.Current;
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(SortedInt32KeyNode<HashBucket> root, Builder builder = null)
			{
				_builder = builder;
				_mapEnumerator = new SortedInt32KeyNode<HashBucket>.Enumerator(root);
				_bucketEnumerator = default(HashBucket.Enumerator);
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
			}

			public bool MoveNext()
			{
				ThrowIfChanged();
				if (_bucketEnumerator.MoveNext())
				{
					return true;
				}
				if (_mapEnumerator.MoveNext())
				{
					_bucketEnumerator = new HashBucket.Enumerator(_mapEnumerator.Current.Value);
					return _bucketEnumerator.MoveNext();
				}
				return false;
			}

			public void Reset()
			{
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_mapEnumerator.Reset();
				_bucketEnumerator.Dispose();
				_bucketEnumerator = default(HashBucket.Enumerator);
			}

			public void Dispose()
			{
				_mapEnumerator.Dispose();
				_bucketEnumerator.Dispose();
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}
		}

		internal enum OperationResult
		{
			SizeChanged,
			NoChangeRequired
		}

		[<d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		internal struct HashBucket
		{
			internal struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
			{
				private enum Position
				{
					BeforeFirst,
					First,
					Additional,
					End
				}

				private readonly HashBucket _bucket;

				private bool _disposed;

				private Position _currentPosition;

				private ImmutableList<T>.Enumerator _additionalEnumerator;

				object IEnumerator.Current => Current;

				public T Current
				{
					get
					{
						ThrowIfDisposed();
						return _currentPosition switch
						{
							Position.First => _bucket._firstValue, 
							Position.Additional => _additionalEnumerator.Current, 
							_ => throw new InvalidOperationException(), 
						};
					}
				}

				internal Enumerator(HashBucket bucket)
				{
					_disposed = false;
					_bucket = bucket;
					_currentPosition = Position.BeforeFirst;
					_additionalEnumerator = default(ImmutableList<T>.Enumerator);
				}

				public bool MoveNext()
				{
					ThrowIfDisposed();
					if (_bucket.IsEmpty)
					{
						_currentPosition = Position.End;
						return false;
					}
					switch (_currentPosition)
					{
					case Position.BeforeFirst:
						_currentPosition = Position.First;
						return true;
					case Position.First:
						if (_bucket._additionalElements.IsEmpty)
						{
							_currentPosition = Position.End;
							return false;
						}
						_currentPosition = Position.Additional;
						_additionalEnumerator = new ImmutableList<T>.Enumerator(_bucket._additionalElements);
						return _additionalEnumerator.MoveNext();
					case Position.Additional:
						return _additionalEnumerator.MoveNext();
					case Position.End:
						return false;
					default:
						throw new InvalidOperationException();
					}
				}

				public void Reset()
				{
					ThrowIfDisposed();
					_additionalEnumerator.Dispose();
					_currentPosition = Position.BeforeFirst;
				}

				public void Dispose()
				{
					_disposed = true;
					_additionalEnumerator.Dispose();
				}

				private void ThrowIfDisposed()
				{
					if (_disposed)
					{
						Requires.FailObjectDisposed(this);
					}
				}
			}

			private readonly T _firstValue;

			private readonly ImmutableList<T>.Node _additionalElements;

			internal bool IsEmpty => _additionalElements == null;

			private HashBucket(T firstElement, ImmutableList<T>.Node additionalElements = null)
			{
				_firstValue = firstElement;
				_additionalElements = additionalElements ?? ImmutableList<T>.Node.EmptyNode;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			public override bool Equals(object obj)
			{
				throw new NotSupportedException();
			}

			public override int GetHashCode()
			{
				throw new NotSupportedException();
			}

			internal bool EqualsByRef(HashBucket other)
			{
				if ((object)_firstValue == (object)other._firstValue)
				{
					return _additionalElements == other._additionalElements;
				}
				return false;
			}

			internal bool EqualsByValue(HashBucket other, IEqualityComparer<T> valueComparer)
			{
				if (valueComparer.Equals(_firstValue, other._firstValue))
				{
					return _additionalElements == other._additionalElements;
				}
				return false;
			}

			internal HashBucket Add(T value, IEqualityComparer<T> valueComparer, out OperationResult result)
			{
				if (IsEmpty)
				{
					result = OperationResult.SizeChanged;
					return new HashBucket(value);
				}
				if (valueComparer.Equals(value, _firstValue) || _additionalElements.IndexOf(value, valueComparer) >= 0)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				result = OperationResult.SizeChanged;
				return new HashBucket(_firstValue, _additionalElements.Add(value));
			}

			internal bool Contains(T value, IEqualityComparer<T> valueComparer)
			{
				if (IsEmpty)
				{
					return false;
				}
				if (!valueComparer.Equals(value, _firstValue))
				{
					return _additionalElements.IndexOf(value, valueComparer) >= 0;
				}
				return true;
			}

			internal bool TryExchange(T value, IEqualityComparer<T> valueComparer, out T existingValue)
			{
				if (!IsEmpty)
				{
					if (valueComparer.Equals(value, _firstValue))
					{
						existingValue = _firstValue;
						return true;
					}
					int num = _additionalElements.IndexOf(value, valueComparer);
					if (num >= 0)
					{
						existingValue = _additionalElements.ItemRef(num);
						return true;
					}
				}
				existingValue = value;
				return false;
			}

			internal HashBucket Remove(T value, IEqualityComparer<T> equalityComparer, out OperationResult result)
			{
				if (IsEmpty)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				if (equalityComparer.Equals(_firstValue, value))
				{
					if (_additionalElements.IsEmpty)
					{
						result = OperationResult.SizeChanged;
						return default(HashBucket);
					}
					int count = _additionalElements.Left.Count;
					result = OperationResult.SizeChanged;
					return new HashBucket(_additionalElements.Key, _additionalElements.RemoveAt(count));
				}
				int num = _additionalElements.IndexOf(value, equalityComparer);
				if (num < 0)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				result = OperationResult.SizeChanged;
				return new HashBucket(_firstValue, _additionalElements.RemoveAt(num));
			}

			internal void Freeze()
			{
				if (_additionalElements != null)
				{
					_additionalElements.Freeze();
				}
			}
		}

		[<d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		private struct MutationInput
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly IEqualityComparer<T> _equalityComparer;

			private readonly int _count;

			private readonly IEqualityComparer<HashBucket> _hashBucketEqualityComparer;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal IEqualityComparer<T> EqualityComparer => _equalityComparer;

			internal int Count => _count;

			internal IEqualityComparer<HashBucket> HashBucketEqualityComparer => _hashBucketEqualityComparer;

			internal MutationInput(ImmutableHashSet<T> set)
			{
				Requires.NotNull(set, "set");
				_root = set._root;
				_equalityComparer = set._equalityComparer;
				_count = set._count;
				_hashBucketEqualityComparer = set._hashBucketEqualityComparer;
			}

			internal MutationInput(SortedInt32KeyNode<HashBucket> root, IEqualityComparer<T> equalityComparer, IEqualityComparer<HashBucket> hashBucketEqualityComparer, int count)
			{
				Requires.NotNull(root, "root");
				Requires.NotNull(equalityComparer, "equalityComparer");
				Requires.Range(count >= 0, "count");
				Requires.NotNull(hashBucketEqualityComparer, "hashBucketEqualityComparer");
				_root = root;
				_equalityComparer = equalityComparer;
				_count = count;
				_hashBucketEqualityComparer = hashBucketEqualityComparer;
			}
		}

		private enum CountType
		{
			Adjustment,
			FinalValue
		}

		[<d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		private struct MutationResult
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly int _count;

			private readonly CountType _countType;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal int Count => _count;

			internal CountType CountType => _countType;

			internal MutationResult(SortedInt32KeyNode<HashBucket> root, int count, CountType countType = CountType.Adjustment)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_count = count;
				_countType = countType;
			}

			internal ImmutableHashSet<T> Finalize(ImmutableHashSet<T> priorSet)
			{
				Requires.NotNull(priorSet, "priorSet");
				int num = Count;
				if (CountType == CountType.Adjustment)
				{
					num += priorSet._count;
				}
				return priorSet.Wrap(Root, num);
			}
		}

		[<d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		private struct NodeEnumerable : IEnumerable<T>, IEnumerable
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			internal NodeEnumerable(SortedInt32KeyNode<HashBucket> root)
			{
				Requires.NotNull(root, "root");
				_root = root;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_root);
			}

			[ExcludeFromCodeCoverage]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			[ExcludeFromCodeCoverage]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		public static readonly ImmutableHashSet<T> Empty = new ImmutableHashSet<T>(SortedInt32KeyNode<HashBucket>.EmptyNode, EqualityComparer<T>.Default, 0);

		private static readonly Action<KeyValuePair<int, HashBucket>> s_FreezeBucketAction = delegate(KeyValuePair<int, HashBucket> kv)
		{
			kv.Value.Freeze();
		};

		private readonly IEqualityComparer<T> _equalityComparer;

		private readonly int _count;

		private readonly SortedInt32KeyNode<HashBucket> _root;

		private readonly IEqualityComparer<HashBucket> _hashBucketEqualityComparer;

		public int Count => _count;

		public bool IsEmpty => Count == 0;

		public IEqualityComparer<T> KeyComparer => _equalityComparer;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		internal IBinaryTree Root => _root;

		private MutationInput Origin => new MutationInput(this);

		bool ICollection<T>.IsReadOnly => true;

		internal ImmutableHashSet(IEqualityComparer<T> equalityComparer)
			: this(SortedInt32KeyNode<HashBucket>.EmptyNode, equalityComparer, 0)
		{
		}

		private ImmutableHashSet(SortedInt32KeyNode<HashBucket> root, IEqualityComparer<T> equalityComparer, int count)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(equalityComparer, "equalityComparer");
			root.Freeze(s_FreezeBucketAction);
			_root = root;
			_count = count;
			_equalityComparer = equalityComparer;
			_hashBucketEqualityComparer = GetHashBucketEqualityComparer(equalityComparer);
		}

		public ImmutableHashSet<T> Clear()
		{
			if (!IsEmpty)
			{
				return Empty.WithComparer(_equalityComparer);
			}
			return this;
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Clear()
		{
			return Clear();
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableHashSet<T> Add(T item)
		{
			return Add(item, Origin).Finalize(this);
		}

		public ImmutableHashSet<T> Remove(T item)
		{
			return Remove(item, Origin).Finalize(this);
		}

		public bool TryGetValue(T equalValue, out T actualValue)
		{
			int hashCode = _equalityComparer.GetHashCode(equalValue);
			if (_root.TryGetValue(hashCode, out var value))
			{
				return value.TryExchange(equalValue, _equalityComparer, out actualValue);
			}
			actualValue = equalValue;
			return false;
		}

		public ImmutableHashSet<T> Union(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Union(other, avoidWithComparer: false);
		}

		public ImmutableHashSet<T> Intersect(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Intersect(other, Origin).Finalize(this);
		}

		public ImmutableHashSet<T> Except(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Except(other, _equalityComparer, _hashBucketEqualityComparer, _root).Finalize(this);
		}

		public ImmutableHashSet<T> SymmetricExcept(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return SymmetricExcept(other, Origin).Finalize(this);
		}

		public bool SetEquals(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (this == other)
			{
				return true;
			}
			return SetEquals(other, Origin);
		}

		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsProperSubsetOf(other, Origin);
		}

		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsProperSupersetOf(other, Origin);
		}

		public bool IsSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsSubsetOf(other, Origin);
		}

		public bool IsSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return IsSupersetOf(other, Origin);
		}

		public bool Overlaps(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			return Overlaps(other, Origin);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Add(T item)
		{
			return Add(item);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Remove(T item)
		{
			return Remove(item);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Union(IEnumerable<T> other)
		{
			return Union(other);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Intersect(IEnumerable<T> other)
		{
			return Intersect(other);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Except(IEnumerable<T> other)
		{
			return Except(other);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other)
		{
			return SymmetricExcept(other);
		}

		public bool Contains(T item)
		{
			return Contains(item, Origin);
		}

		public ImmutableHashSet<T> WithComparer(IEqualityComparer<T> equalityComparer)
		{
			if (equalityComparer == null)
			{
				equalityComparer = EqualityComparer<T>.Default;
			}
			if (equalityComparer == _equalityComparer)
			{
				return this;
			}
			ImmutableHashSet<T> immutableHashSet = new ImmutableHashSet<T>(equalityComparer);
			return immutableHashSet.Union(this, avoidWithComparer: true);
		}

		bool ISet<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.ExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.IntersectWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.SymmetricExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.UnionWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array.SetValue(current, arrayIndex++);
			}
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(_root);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private static bool IsSupersetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (!Contains(item, origin))
				{
					return false;
				}
			}
			return true;
		}

		private static MutationResult Add(T item, MutationInput origin)
		{
			int hashCode = origin.EqualityComparer.GetHashCode(item);
			OperationResult result;
			HashBucket newBucket = origin.Root.GetValueOrDefault(hashCode).Add(item, origin.EqualityComparer, out result);
			if (result == OperationResult.NoChangeRequired)
			{
				return new MutationResult(origin.Root, 0);
			}
			SortedInt32KeyNode<HashBucket> root = UpdateRoot(origin.Root, hashCode, origin.HashBucketEqualityComparer, newBucket);
			return new MutationResult(root, 1);
		}

		private static MutationResult Remove(T item, MutationInput origin)
		{
			OperationResult result = OperationResult.NoChangeRequired;
			int hashCode = origin.EqualityComparer.GetHashCode(item);
			SortedInt32KeyNode<HashBucket> root = origin.Root;
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				HashBucket newBucket = value.Remove(item, origin.EqualityComparer, out result);
				if (result == OperationResult.NoChangeRequired)
				{
					return new MutationResult(origin.Root, 0);
				}
				root = UpdateRoot(origin.Root, hashCode, origin.HashBucketEqualityComparer, newBucket);
			}
			return new MutationResult(root, (result == OperationResult.SizeChanged) ? (-1) : 0);
		}

		private static bool Contains(T item, MutationInput origin)
		{
			int hashCode = origin.EqualityComparer.GetHashCode(item);
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				return value.Contains(item, origin.EqualityComparer);
			}
			return false;
		}

		private static MutationResult Union(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			int num = 0;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = origin.Root;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				int hashCode = origin.EqualityComparer.GetHashCode(item);
				OperationResult result;
				HashBucket newBucket = sortedInt32KeyNode.GetValueOrDefault(hashCode).Add(item, origin.EqualityComparer, out result);
				if (result == OperationResult.SizeChanged)
				{
					sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, hashCode, origin.HashBucketEqualityComparer, newBucket);
					num++;
				}
			}
			return new MutationResult(sortedInt32KeyNode, num);
		}

		private static bool Overlaps(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return false;
			}
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item, origin))
				{
					return true;
				}
			}
			return false;
		}

		private static bool SetEquals(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			HashSet<T> hashSet = new HashSet<T>(other, origin.EqualityComparer);
			if (origin.Count != hashSet.Count)
			{
				return false;
			}
			foreach (T item in hashSet)
			{
				if (!Contains(item, origin))
				{
					return false;
				}
			}
			return true;
		}

		private static SortedInt32KeyNode<HashBucket> UpdateRoot(SortedInt32KeyNode<HashBucket> root, int hashCode, IEqualityComparer<HashBucket> hashBucketEqualityComparer, HashBucket newBucket)
		{
			bool mutated;
			if (newBucket.IsEmpty)
			{
				return root.Remove(hashCode, out mutated);
			}
			bool replacedExistingValue;
			return root.SetItem(hashCode, newBucket, hashBucketEqualityComparer, out replacedExistingValue, out mutated);
		}

		private static MutationResult Intersect(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			SortedInt32KeyNode<HashBucket> root = SortedInt32KeyNode<HashBucket>.EmptyNode;
			int num = 0;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item, origin))
				{
					MutationResult mutationResult = Add(item, new MutationInput(root, origin.EqualityComparer, origin.HashBucketEqualityComparer, num));
					root = mutationResult.Root;
					num += mutationResult.Count;
				}
			}
			return new MutationResult(root, num, CountType.FinalValue);
		}

		private static MutationResult Except(IEnumerable<T> other, IEqualityComparer<T> equalityComparer, IEqualityComparer<HashBucket> hashBucketEqualityComparer, SortedInt32KeyNode<HashBucket> root)
		{
			Requires.NotNull(other, "other");
			Requires.NotNull(equalityComparer, "equalityComparer");
			Requires.NotNull(root, "root");
			int num = 0;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = root;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				int hashCode = equalityComparer.GetHashCode(item);
				if (sortedInt32KeyNode.TryGetValue(hashCode, out var value))
				{
					OperationResult result;
					HashBucket newBucket = value.Remove(item, equalityComparer, out result);
					if (result == OperationResult.SizeChanged)
					{
						num--;
						sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, hashCode, hashBucketEqualityComparer, newBucket);
					}
				}
			}
			return new MutationResult(sortedInt32KeyNode, num);
		}

		private static MutationResult SymmetricExcept(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			ImmutableHashSet<T> immutableHashSet = ImmutableHashSet.CreateRange(origin.EqualityComparer, other);
			int num = 0;
			SortedInt32KeyNode<HashBucket> root = SortedInt32KeyNode<HashBucket>.EmptyNode;
			foreach (T item in new NodeEnumerable(origin.Root))
			{
				if (!immutableHashSet.Contains(item))
				{
					MutationResult mutationResult = Add(item, new MutationInput(root, origin.EqualityComparer, origin.HashBucketEqualityComparer, num));
					root = mutationResult.Root;
					num += mutationResult.Count;
				}
			}
			foreach (T item2 in immutableHashSet)
			{
				if (!Contains(item2, origin))
				{
					MutationResult mutationResult2 = Add(item2, new MutationInput(root, origin.EqualityComparer, origin.HashBucketEqualityComparer, num));
					root = mutationResult2.Root;
					num += mutationResult2.Count;
				}
			}
			return new MutationResult(root, num, CountType.FinalValue);
		}

		private static bool IsProperSubsetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return other.Any();
			}
			HashSet<T> hashSet = new HashSet<T>(other, origin.EqualityComparer);
			if (origin.Count >= hashSet.Count)
			{
				return false;
			}
			int num = 0;
			bool flag = false;
			foreach (T item in hashSet)
			{
				if (Contains(item, origin))
				{
					num++;
				}
				else
				{
					flag = true;
				}
				if (num == origin.Count && flag)
				{
					return true;
				}
			}
			return false;
		}

		private static bool IsProperSupersetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return false;
			}
			int num = 0;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				num++;
				if (!Contains(item, origin))
				{
					return false;
				}
			}
			return origin.Count > num;
		}

		private static bool IsSubsetOf(IEnumerable<T> other, MutationInput origin)
		{
			Requires.NotNull(other, "other");
			if (origin.Root.IsEmpty)
			{
				return true;
			}
			HashSet<T> hashSet = new HashSet<T>(other, origin.EqualityComparer);
			int num = 0;
			foreach (T item in hashSet)
			{
				if (Contains(item, origin))
				{
					num++;
				}
			}
			return num == origin.Count;
		}

		private static ImmutableHashSet<T> Wrap(SortedInt32KeyNode<HashBucket> root, IEqualityComparer<T> equalityComparer, int count)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(equalityComparer, "equalityComparer");
			Requires.Range(count >= 0, "count");
			return new ImmutableHashSet<T>(root, equalityComparer, count);
		}

		private static IEqualityComparer<HashBucket> GetHashBucketEqualityComparer(IEqualityComparer<T> valueComparer)
		{
			if (!ImmutableExtensions.IsValueType<T>())
			{
				return HashBucketByRefEqualityComparer.DefaultInstance;
			}
			if (valueComparer == EqualityComparer<T>.Default)
			{
				return HashBucketByValueEqualityComparer.DefaultInstance;
			}
			return new HashBucketByValueEqualityComparer(valueComparer);
		}

		private ImmutableHashSet<T> Wrap(SortedInt32KeyNode<HashBucket> root, int adjustedCountIfDifferentRoot)
		{
			if (root == _root)
			{
				return this;
			}
			return new ImmutableHashSet<T>(root, _equalityComparer, adjustedCountIfDifferentRoot);
		}

		private ImmutableHashSet<T> Union(IEnumerable<T> items, bool avoidWithComparer)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty && !avoidWithComparer && items is ImmutableHashSet<T> immutableHashSet)
			{
				return immutableHashSet.WithComparer(KeyComparer);
			}
			return Union(items, Origin).Finalize(this);
		}
	}
	internal interface IStrongEnumerable<out T, TEnumerator> where TEnumerator : struct, IStrongEnumerator<T>
	{
		TEnumerator GetEnumerator();
	}
	internal interface IStrongEnumerator<T>
	{
		T Current { get; }

		bool MoveNext();
	}
	internal interface IOrderedCollection<out T> : IEnumerable<T>, IEnumerable
	{
		int Count { get; }

		T this[int index] { get; }
	}
	internal static class ImmutableArray
	{
		internal static readonly byte[] TwoElementArray = new byte[2];

		public static ImmutableArray<T> Create<T>()
		{
			return ImmutableArray<T>.Empty;
		}

		public static ImmutableArray<T> Create<T>(T item)
		{
			T[] items = new T[1] { item };
			return new ImmutableArray<T>(items);
		}

		public static ImmutableArray<T> Create<T>(T item1, T item2)
		{
			T[] items = new T[2] { item1, item2 };
			return new ImmutableArray<T>(items);
		}

		public static ImmutableArray<T> Create<T>(T item1, T item2, T item3)
		{
			T[] items = new T[3] { item1, item2, item3 };
			return new ImmutableArray<T>(items);
		}

		public static ImmutableArray<T> Create<T>(T item1, T item2, T item3, T item4)
		{
			T[] items = new T[4] { item1, item2, item3, item4 };
			return new ImmutableArray<T>(items);
		}

		public static ImmutableArray<T> CreateRange<T>(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			if (items is IImmutableArray immutableArray)
			{
				Array array = immutableArray.Array;
				if (array == null)
				{
					throw new InvalidOperationException(System.SR.InvalidOperationOnDefaultArray);
				}
				return new ImmutableArray<T>((T[])array);
			}
			if (items.TryGetCount(out var count))
			{
				return new ImmutableArray<T>(items.ToArray(count));
			}
			return new ImmutableArray<T>(items.ToArray());
		}

		public static ImmutableArray<T> Create<T>(params T[] items)
		{
			if (items == null)
			{
				return Create<T>();
			}
			return CreateDefensiveCopy(items);
		}

		public static ImmutableArray<T> Create<T>(T[] items, int start, int length)
		{
			Requires.NotNull(items, "items");
			Requires.Range(start >= 0 && start <= items.Length, "start");
			Requires.Range(length >= 0 && start + length <= items.Length, "length");
			if (length == 0)
			{
				return Create<T>();
			}
			T[] array = new T[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = items[start + i];
			}
			return new ImmutableArray<T>(array);
		}

		public static ImmutableArray<T> Create<T>(ImmutableArray<T> items, int start, int length)
		{
			Requires.Range(start >= 0 && start <= items.Length, "start");
			Requires.Range(length >= 0 && start + length <= items.Length, "length");
			if (length == 0)
			{
				return Create<T>();
			}
			if (start == 0 && length == items.Length)
			{
				return items;
			}
			T[] array = new T[length];
			Array.Copy(items.array, start, array, 0, length);
			return new ImmutableArray<T>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, Func<TSource, TResult> selector)
		{
			Requires.NotNull(selector, "selector");
			int length = items.Length;
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i]);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TResult> selector)
		{
			int length2 = items.Length;
			Requires.Range(start >= 0 && start <= length2, "start");
			Requires.Range(length >= 0 && start + length <= length2, "length");
			Requires.NotNull(selector, "selector");
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i + start]);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, Func<TSource, TArg, TResult> selector, TArg arg)
		{
			Requires.NotNull(selector, "selector");
			int length = items.Length;
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i], arg);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<TResult> CreateRange<TSource, TArg, TResult>(ImmutableArray<TSource> items, int start, int length, Func<TSource, TArg, TResult> selector, TArg arg)
		{
			int length2 = items.Length;
			Requires.Range(start >= 0 && start <= length2, "start");
			Requires.Range(length >= 0 && start + length <= length2, "length");
			Requires.NotNull(selector, "selector");
			if (length == 0)
			{
				return Create<TResult>();
			}
			TResult[] array = new TResult[length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = selector(items[i + start], arg);
			}
			return new ImmutableArray<TResult>(array);
		}

		public static ImmutableArray<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableArray<T>.Builder CreateBuilder<T>(int initialCapacity)
		{
			return new ImmutableArray<T>.Builder(initialCapacity);
		}

		public static ImmutableArray<TSource> ToImmutableArray<TSource>(this IEnumerable<TSource> items)
		{
			if (items is ImmutableArray<TSource>)
			{
				return (ImmutableArray<TSource>)(object)items;
			}
			return CreateRange(items);
		}

		public static ImmutableArray<TSource> ToImmutableArray<TSource>(this ImmutableArray<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, T value)
		{
			return Array.BinarySearch(array.array, value);
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, T value, IComparer<T> comparer)
		{
			return Array.BinarySearch(array.array, value, comparer);
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value)
		{
			return Array.BinarySearch(array.array, index, length, value);
		}

		public static int BinarySearch<T>(this ImmutableArray<T> array, int index, int length, T value, IComparer<T> comparer)
		{
			return Array.BinarySearch(array.array, index, length, value, comparer);
		}

		internal static ImmutableArray<T> CreateDefensiveCopy<T>(T[] items)
		{
			if (items.Length == 0)
			{
				return ImmutableArray<T>.Empty;
			}
			T[] array = new T[items.Length];
			Array.Copy(items, 0, array, 0, items.Length);
			return new ImmutableArray<T>(array);
		}
	}
	[DebuggerDisplay("{DebuggerDisplay,nq}")]
	[<697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionable]
	internal struct ImmutableArray<T> : IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IList<T>, ICollection<T>, IEquatable<ImmutableArray<T>>, IList, ICollection, IImmutableArray, IStructuralComparable, IStructuralEquatable, IImmutableList<T>
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableArrayBuilderDebuggerProxy<>))]
		public sealed class Builder : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyList<T>, IReadOnlyCollection<T>
		{
			private T[] _elements;

			private int _count;

			public int Capacity
			{
				get
				{
					return _elements.Length;
				}
				set
				{
					if (value < _count)
					{
						throw new ArgumentException(System.SR.CapacityMustBeGreaterThanOrEqualToCount, "value");
					}
					if (value == _elements.Length)
					{
						return;
					}
					if (value > 0)
					{
						T[] array = new T[value];
						if (_count > 0)
						{
							Array.Copy(_elements, 0, array, 0, _count);
						}
						_elements = array;
					}
					else
					{
						_elements = ImmutableArray<T>.Empty.array;
					}
				}
			}

			public int Count
			{
				get
				{
					return _count;
				}
				set
				{
					Requires.Range(value >= 0, "value");
					if (value < _count)
					{
						if (_count - value > 64)
						{
							Array.Clear(_elements, value, _count - value);
						}
						else
						{
							for (int i = value; i < Count; i++)
							{
								_elements[i] = default(T);
							}
						}
					}
					else if (value > _count)
					{
						EnsureCapacity(value);
					}
					_count = value;
				}
			}

			public T this[int index]
			{
				get
				{
					if (index >= Count)
					{
						ThrowIndexOutOfRangeException();
					}
					return _elements[index];
				}
				set
				{
					if (index >= Count)
					{
						ThrowIndexOutOfRangeException();
					}
					_elements[index] = value;
				}
			}

			bool ICollection<T>.IsReadOnly => false;

			internal Builder(int capacity)
			{
				Requires.Range(capacity >= 0, "capacity");
				_elements = new T[capacity];
				_count = 0;
			}

			internal Builder()
				: this(8)
			{
			}

			private static void ThrowIndexOutOfRangeException()
			{
				throw new IndexOutOfRangeException();
			}

			[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
			public ref T ItemRef(int index)
			{
				if (index >= Count)
				{
					ThrowIndexOutOfRangeException();
				}
				return ref _elements[index];
			}

			public ImmutableArray<T> ToImmutable()
			{
				return new ImmutableArray<T>(ToArray());
			}

			public ImmutableArray<T> MoveToImmutable()
			{
				if (Capacity != Count)
				{
					throw new InvalidOperationException(System.SR.CapacityMustEqualCountOnMove);
				}
				T[] elements = _elements;
				_elements = ImmutableArray<T>.Empty.array;
				_count = 0;
				return new ImmutableArray<T>(elements);
			}

			public void Clear()
			{
				Count = 0;
			}

			public void Insert(int index, T item)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				EnsureCapacity(Count + 1);
				if (index < Count)
				{
					Array.Copy(_elements, index, _elements, index + 1, Count - index);
				}
				_count++;
				_elements[index] = item;
			}

			public void Add(T item)
			{
				int num = _count + 1;
				EnsureCapacity(num);
				_elements[_count] = item;
				_count = num;
			}

			public void AddRange(IEnumerable<T> items)
			{
				Requires.NotNull(items, "items");
				if (items.TryGetCount(out var count))
				{
					EnsureCapacity(Count + count);
					if (items.TryCopyTo(_elements, _count))
					{
						_count += count;
						return;
					}
				}
				foreach (T item in items)
				{
					Add(item);
				}
			}

			public void AddRange(params T[] items)
			{
				Requires.NotNull(items, "items");
				int count = Count;
				Count += items.Length;
				Array.Copy(items, 0, _elements, count, items.Length);
			}

			public void AddRange<TDerived>(TDerived[] items) where TDerived : T
			{
				Requires.NotNull(items, "items");
				int count = Count;
				Count += items.Length;
				Array.Copy(items, 0, _elements, count, items.Length);
			}

			public void AddRange(T[] items, int length)
			{
				Requires.NotNull(items, "items");
				Requires.Range(length >= 0 && length <= items.Length, "length");
				int count = Count;
				Count += length;
				Array.Copy(items, 0, _elements, count, length);
			}

			public void AddRange(ImmutableArray<T> items)
			{
				AddRange(items, items.Length);
			}

			public void AddRange(ImmutableArray<T> items, int length)
			{
				Requires.Range(length >= 0, "length");
				if (items.array != null)
				{
					AddRange(items.array, length);
				}
			}

			public void AddRange<TDerived>(ImmutableArray<TDerived> items) where TDerived : T
			{
				if (items.array != null)
				{
					AddRange(items.array);
				}
			}

			public void AddRange(Builder items)
			{
				Requires.NotNull(items, "items");
				AddRange(items._elements, items.Count);
			}

			public void AddRange<TDerived>(ImmutableArray<TDerived>.Builder items) where TDerived : T
			{
				Requires.NotNull(items, "items");
				AddRange(items._elements, items.Count);
			}

			public bool Remove(T element)
			{
				int num = IndexOf(element);
				if (num >= 0)
				{
					RemoveAt(num);
					return true;
				}
				return false;
			}

			public void RemoveAt(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				if (index < Count - 1)
				{
					Array.Copy(_elements, index + 1, _elements, index, Count - index - 1);
				}
				Count--;
			}

			public bool Contains(T item)
			{
				return IndexOf(item) >= 0;
			}

			public T[] ToArray()
			{
				if (Count == 0)
				{
					return ImmutableArray<T>.Empty.array;
				}
				T[] array = new T[Count];
				Array.Copy(_elements, 0, array, 0, Count);
				return array;
			}

			public void CopyTo(T[] array, int index)
			{
				Requires.NotNull(array, "array");
				Requires.Range(index >= 0 && index + Count <= array.Length, "index");
				Array.Copy(_elements, 0, array, index, Count);
			}

			private void EnsureCapacity(int capacity)
			{
				if (_elements.Length < capacity)
				{
					int newSize = Math.Max(_elements.Length * 2, capacity);
					Array.Resize(ref _elements, newSize);
				}
			}

			public int IndexOf(T item)
			{
				return IndexOf(item, 0, _count, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int startIndex)
			{
				return IndexOf(item, startIndex, Count - startIndex, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int startIndex, int count)
			{
				return IndexOf(item, startIndex, count, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer)
			{
				if (count == 0 && startIndex == 0)
				{
					return -1;
				}
				Requires.Range(startIndex >= 0 && startIndex < Count, "startIndex");
				Requires.Range(count >= 0 && startIndex + count <= Count, "count");
				equalityComparer = equalityComparer ?? EqualityComparer<T>.Default;
				if (equalityComparer == EqualityComparer<T>.Default)
				{
					return Array.IndexOf(_elements, item, startIndex, count);
				}
				for (int i = startIndex; i < startIndex + count; i++)
				{
					if (equalityComparer.Equals(_elements[i], item))
					{
						return i;
					}
				}
				return -1;
			}

			public int LastIndexOf(T item)
			{
				if (Count == 0)
				{
					return -1;
				}
				return LastIndexOf(item, Count - 1, Count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex)
			{
				if (Count == 0 && startIndex == 0)
				{
					return -1;
				}
				Requires.Range(startIndex >= 0 && startIndex < Count, "startIndex");
				return LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count)
			{
				return LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer)
			{
				if (count == 0 && startIndex == 0)
				{
					return -1;
				}
				Requires.Range(startIndex >= 0 && startIndex < Count, "startIndex");
				Requires.Range(count >= 0 && startIndex - count + 1 >= 0, "count");
				equalityComparer = equalityComparer ?? EqualityComparer<T>.Default;
				if (equalityComparer == EqualityComparer<T>.Default)
				{
					return Array.LastIndexOf(_elements, item, startIndex, count);
				}
				for (int num = startIndex; num >= startIndex - count + 1; num--)
				{
					if (equalityComparer.Equals(item, _elements[num]))
					{
						return num;
					}
				}
				return -1;
			}

			public void Reverse()
			{
				int num = 0;
				int num2 = _count - 1;
				T[] elements = _elements;
				while (num < num2)
				{
					T val = elements[num];
					elements[num] = elements[num2];
					elements[num2] = val;
					num++;
					num2--;
				}
			}

			public void Sort()
			{
				if (Count > 1)
				{
					Array.Sort(_elements, 0, Count, Comparer<T>.Default);
				}
			}

			public void Sort(Comparison<T> comparison)
			{
				Requires.NotNull(comparison, "comparison");
				if (Count > 1)
				{
					Array.Sort(_elements, 0, _count, Comparer<T>.Create(comparison));
				}
			}

			public void Sort(IComparer<T> comparer)
			{
				if (Count > 1)
				{
					Array.Sort(_elements, 0, _count, comparer);
				}
			}

			public void Sort(int index, int count, IComparer<T> comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0 && index + count <= Count, "count");
				if (count > 1)
				{
					Array.Sort(_elements, index, count, comparer);
				}
			}

			public IEnumerator<T> GetEnumerator()
			{
				for (int i = 0; i < Count; i++)
				{
					yield return this[i];
				}
			}

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

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private void AddRange<TDerived>(TDerived[] items, int length) where TDerived : T
			{
				EnsureCapacity(Count + length);
				int count = Count;
				Count += length;
				T[] elements = _elements;
				for (int i = 0; i < length; i++)
				{
					elements[count + i] = (T)(object)items[i];
				}
			}
		}

		public struct Enumerator
		{
			private readonly T[] _array;

			private int _index;

			public T Current => _array[_index];

			internal Enumerator(T[] array)
			{
				_array = array;
				_index = -1;
			}

			public bool MoveNext()
			{
				return ++_index < _array.Length;
			}
		}

		private class EnumeratorObject : IEnumerator<T>, IDisposable, IEnumerator
		{
			private static readonly IEnumerator<T> s_EmptyEnumerator = new EnumeratorObject(ImmutableArray<T>.Empty.array);

			private readonly T[] _array;

			private int _index;

			public T Current
			{
				get
				{
					if ((uint)_index < (uint)_array.Length)
					{
						return _array[_index];
					}
					throw new InvalidOperationException();
				}
			}

			object IEnumerator.Current => Current;

			private EnumeratorObject(T[] array)
			{
				_index = -1;
				_array = array;
			}

			public bool MoveNext()
			{
				int num = _index + 1;
				int num2 = _array.Length;
				if ((uint)num <= (uint)num2)
				{
					_index = num;
					return (uint)num < (uint)num2;
				}
				return false;
			}

			void IEnumerator.Reset()
			{
				_index = -1;
			}

			public void Dispose()
			{
			}

			internal static IEnumerator<T> Create(T[] array)
			{
				if (array.Length != 0)
				{
					return new EnumeratorObject(array);
				}
				return s_EmptyEnumerator;
			}
		}

		public static readonly ImmutableArray<T> Empty = new ImmutableArray<T>(new T[0]);

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		internal T[] array;

		T IList<T>.this[int index]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection<T>.IsReadOnly => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		int ICollection<T>.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		int IReadOnlyCollection<T>.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		T IReadOnlyList<T>.this[int index]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[index];
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		[ExcludeFromCodeCoverage]
		bool IList.IsFixedSize => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		[ExcludeFromCodeCoverage]
		bool IList.IsReadOnly => true;

		[ExcludeFromCodeCoverage]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		int ICollection.Count
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray.Length;
			}
		}

		[ExcludeFromCodeCoverage]
		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		[ExcludeFromCodeCoverage]
		object ICollection.SyncRoot
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		[ExcludeFromCodeCoverage]
		object IList.this[int index]
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				immutableArray.ThrowInvalidOperationIfNotInitialized();
				return immutableArray[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		public T this[int index]
		{
			[<697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionable]
			get
			{
				return array[index];
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsEmpty
		{
			[<697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionable]
			get
			{
				return Length == 0;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public int Length
		{
			[<697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionable]
			get
			{
				return array.Length;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDefault => array == null;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsDefaultOrEmpty
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				if (immutableArray.array != null)
				{
					return immutableArray.array.Length == 0;
				}
				return true;
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		Array IImmutableArray.Array => array;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		private string DebuggerDisplay
		{
			get
			{
				ImmutableArray<T> immutableArray = this;
				if (!immutableArray.IsDefault)
				{
					return string.Format(CultureInfo.CurrentCulture, "Length = {0}", immutableArray.Length);
				}
				return "Uninitialized";
			}
		}

		public ReadOnlySpan<T> AsSpan()
		{
			return new ReadOnlySpan<T>(array);
		}

		public ReadOnlyMemory<T> AsMemory()
		{
			return new ReadOnlyMemory<T>(array);
		}

		public int IndexOf(T item)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.IndexOf(item, 0, immutableArray.Length, EqualityComparer<T>.Default);
		}

		public int IndexOf(T item, int startIndex, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.IndexOf(item, startIndex, immutableArray.Length - startIndex, equalityComparer);
		}

		public int IndexOf(T item, int startIndex)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.IndexOf(item, startIndex, immutableArray.Length - startIndex, EqualityComparer<T>.Default);
		}

		public int IndexOf(T item, int startIndex, int count)
		{
			return IndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}

		public int IndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			if (count == 0 && startIndex == 0)
			{
				return -1;
			}
			Requires.Range(startIndex >= 0 && startIndex < immutableArray.Length, "startIndex");
			Requires.Range(count >= 0 && startIndex + count <= immutableArray.Length, "count");
			equalityComparer = equalityComparer ?? EqualityComparer<T>.Default;
			if (equalityComparer == EqualityComparer<T>.Default)
			{
				return Array.IndexOf(immutableArray.array, item, startIndex, count);
			}
			for (int i = startIndex; i < startIndex + count; i++)
			{
				if (equalityComparer.Equals(immutableArray.array[i], item))
				{
					return i;
				}
			}
			return -1;
		}

		public int LastIndexOf(T item)
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.Length == 0)
			{
				return -1;
			}
			return immutableArray.LastIndexOf(item, immutableArray.Length - 1, immutableArray.Length, EqualityComparer<T>.Default);
		}

		public int LastIndexOf(T item, int startIndex)
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.Length == 0 && startIndex == 0)
			{
				return -1;
			}
			return immutableArray.LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
		}

		public int LastIndexOf(T item, int startIndex, int count)
		{
			return LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}

		public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			if (startIndex == 0 && count == 0)
			{
				return -1;
			}
			Requires.Range(startIndex >= 0 && startIndex < immutableArray.Length, "startIndex");
			Requires.Range(count >= 0 && startIndex - count + 1 >= 0, "count");
			equalityComparer = equalityComparer ?? EqualityComparer<T>.Default;
			if (equalityComparer == EqualityComparer<T>.Default)
			{
				return Array.LastIndexOf(immutableArray.array, item, startIndex, count);
			}
			for (int num = startIndex; num >= startIndex - count + 1; num--)
			{
				if (equalityComparer.Equals(item, immutableArray.array[num]))
				{
					return num;
				}
			}
			return -1;
		}

		public bool Contains(T item)
		{
			return IndexOf(item) >= 0;
		}

		public ImmutableArray<T> Insert(int index, T item)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= immutableArray.Length, "index");
			if (immutableArray.Length == 0)
			{
				return ImmutableArray.Create(item);
			}
			T[] array = new T[immutableArray.Length + 1];
			array[index] = item;
			if (index != 0)
			{
				Array.Copy(immutableArray.array, 0, array, 0, index);
			}
			if (index != immutableArray.Length)
			{
				Array.Copy(immutableArray.array, index, array, index + 1, immutableArray.Length - index);
			}
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> InsertRange(int index, IEnumerable<T> items)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			Requires.NotNull(items, "items");
			if (result.Length == 0)
			{
				return ImmutableArray.CreateRange(items);
			}
			int count = ImmutableExtensions.GetCount(ref items);
			if (count == 0)
			{
				return result;
			}
			T[] array = new T[result.Length + count];
			if (index != 0)
			{
				Array.Copy(result.array, 0, array, 0, index);
			}
			if (index != result.Length)
			{
				Array.Copy(result.array, index, array, index + count, result.Length - index);
			}
			if (!items.TryCopyTo(array, index))
			{
				int num = index;
				foreach (T item in items)
				{
					array[num++] = item;
				}
			}
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> InsertRange(int index, ImmutableArray<T> items)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			items.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			if (result.IsEmpty)
			{
				return items;
			}
			if (items.IsEmpty)
			{
				return result;
			}
			T[] array = new T[result.Length + items.Length];
			if (index != 0)
			{
				Array.Copy(result.array, 0, array, 0, index);
			}
			if (index != result.Length)
			{
				Array.Copy(result.array, index, array, index + items.Length, result.Length - index);
			}
			Array.Copy(items.array, 0, array, index, items.Length);
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> Add(T item)
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.Length == 0)
			{
				return ImmutableArray.Create(item);
			}
			return immutableArray.Insert(immutableArray.Length, item);
		}

		public ImmutableArray<T> AddRange(IEnumerable<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.InsertRange(immutableArray.Length, items);
		}

		public ImmutableArray<T> AddRange(ImmutableArray<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.InsertRange(immutableArray.Length, items);
		}

		public ImmutableArray<T> SetItem(int index, T item)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index < immutableArray.Length, "index");
			T[] array = new T[immutableArray.Length];
			Array.Copy(immutableArray.array, 0, array, 0, immutableArray.Length);
			array[index] = item;
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> Replace(T oldValue, T newValue)
		{
			return Replace(oldValue, newValue, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			int num = immutableArray.IndexOf(oldValue, 0, immutableArray.Length, equalityComparer);
			if (num < 0)
			{
				throw new ArgumentException(System.SR.CannotFindOldValue, "oldValue");
			}
			return immutableArray.SetItem(num, newValue);
		}

		public ImmutableArray<T> Remove(T item)
		{
			return Remove(item, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> Remove(T item, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			int num = result.IndexOf(item, 0, result.Length, equalityComparer);
			if (num >= 0)
			{
				return result.RemoveAt(num);
			}
			return result;
		}

		public ImmutableArray<T> RemoveAt(int index)
		{
			return RemoveRange(index, 1);
		}

		public ImmutableArray<T> RemoveRange(int index, int length)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0 && index <= result.Length, "index");
			Requires.Range(length >= 0 && index + length <= result.Length, "length");
			if (length == 0)
			{
				return result;
			}
			T[] array = new T[result.Length - length];
			Array.Copy(result.array, 0, array, 0, index);
			Array.Copy(result.array, index + length, array, index, result.Length - index - length);
			return new ImmutableArray<T>(array);
		}

		public ImmutableArray<T> RemoveRange(IEnumerable<T> items)
		{
			return RemoveRange(items, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Requires.NotNull(items, "items");
			SortedSet<int> sortedSet = new SortedSet<int>();
			foreach (T item in items)
			{
				int num = immutableArray.IndexOf(item, 0, immutableArray.Length, equalityComparer);
				while (num >= 0 && !sortedSet.Add(num) && num + 1 < immutableArray.Length)
				{
					num = immutableArray.IndexOf(item, num + 1, equalityComparer);
				}
			}
			return immutableArray.RemoveAtRange(sortedSet);
		}

		public ImmutableArray<T> RemoveRange(ImmutableArray<T> items)
		{
			return RemoveRange(items, EqualityComparer<T>.Default);
		}

		public ImmutableArray<T> RemoveRange(ImmutableArray<T> items, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> result = this;
			Requires.NotNull(items.array, "items");
			if (items.IsEmpty)
			{
				result.ThrowNullRefIfNotInitialized();
				return result;
			}
			if (items.Length == 1)
			{
				return result.Remove(items[0], equalityComparer);
			}
			return result.RemoveRange(items.array, equalityComparer);
		}

		public ImmutableArray<T> RemoveAll(Predicate<T> match)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.NotNull(match, "match");
			if (result.IsEmpty)
			{
				return result;
			}
			List<int> list = null;
			for (int i = 0; i < result.array.Length; i++)
			{
				if (match(result.array[i]))
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(i);
				}
			}
			if (list == null)
			{
				return result;
			}
			return result.RemoveAtRange(list);
		}

		public ImmutableArray<T> Clear()
		{
			return Empty;
		}

		public ImmutableArray<T> Sort()
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.Sort(0, immutableArray.Length, Comparer<T>.Default);
		}

		public ImmutableArray<T> Sort(Comparison<T> comparison)
		{
			Requires.NotNull(comparison, "comparison");
			ImmutableArray<T> immutableArray = this;
			return immutableArray.Sort(Comparer<T>.Create(comparison));
		}

		public ImmutableArray<T> Sort(IComparer<T> comparer)
		{
			ImmutableArray<T> immutableArray = this;
			return immutableArray.Sort(0, immutableArray.Length, comparer);
		}

		public ImmutableArray<T> Sort(int index, int count, IComparer<T> comparer)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.Range(index >= 0, "index");
			Requires.Range(count >= 0 && index + count <= result.Length, "count");
			if (count > 1)
			{
				if (comparer == null)
				{
					comparer = Comparer<T>.Default;
				}
				bool flag = false;
				for (int i = index + 1; i < index + count; i++)
				{
					if (comparer.Compare(result.array[i - 1], result.array[i]) > 0)
					{
						flag = true;
						break;
					}
				}
				if (flag)
				{
					T[] array = new T[result.Length];
					Array.Copy(result.array, 0, array, 0, result.Length);
					Array.Sort(array, index, count, comparer);
					return new ImmutableArray<T>(array);
				}
			}
			return result;
		}

		public IEnumerable<TResult> OfType<TResult>()
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.array == null || immutableArray.array.Length == 0)
			{
				return Enumerable.Empty<TResult>();
			}
			return immutableArray.array.OfType<TResult>();
		}

		void IList<T>.Insert(int index, T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.Clear()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Clear();
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.Add(T value)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Add(value);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.AddRange(IEnumerable<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.AddRange(items);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.Insert(int index, T element)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Insert(index, element);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.InsertRange(int index, IEnumerable<T> items)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.InsertRange(index, items);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Remove(value, equalityComparer);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveAll(Predicate<T> match)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveAll(match);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveRange(items, equalityComparer);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveRange(int index, int count)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveRange(index, count);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveAt(int index)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.RemoveAt(index);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.SetItem(int index, T value)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.SetItem(index, value);
		}

		IImmutableList<T> IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Replace(oldValue, newValue, equalityComparer);
		}

		[ExcludeFromCodeCoverage]
		int IList.Add(object value)
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		void IList.Clear()
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		bool IList.Contains(object value)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.Contains((T)value);
		}

		[ExcludeFromCodeCoverage]
		int IList.IndexOf(object value)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return immutableArray.IndexOf((T)value);
		}

		[ExcludeFromCodeCoverage]
		void IList.Insert(int index, object value)
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		void IList.Remove(object value)
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		[ExcludeFromCodeCoverage]
		void ICollection.CopyTo(Array array, int index)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			Array.Copy(immutableArray.array, 0, array, index, immutableArray.Length);
		}

		bool IStructuralEquatable.Equals(object other, IEqualityComparer comparer)
		{
			ImmutableArray<T> immutableArray = this;
			Array array = other as Array;
			if (array == null && other is IImmutableArray immutableArray2)
			{
				array = immutableArray2.Array;
				if (immutableArray.array == null && array == null)
				{
					return true;
				}
				if (immutableArray.array == null)
				{
					return false;
				}
			}
			IStructuralEquatable structuralEquatable = immutableArray.array;
			return structuralEquatable.Equals(array, comparer);
		}

		int IStructuralEquatable.GetHashCode(IEqualityComparer comparer)
		{
			ImmutableArray<T> immutableArray = this;
			return ((IStructuralEquatable)immutableArray.array)?.GetHashCode(comparer) ?? immutableArray.GetHashCode();
		}

		int IStructuralComparable.CompareTo(object other, IComparer comparer)
		{
			ImmutableArray<T> immutableArray = this;
			Array array = other as Array;
			if (array == null && other is IImmutableArray immutableArray2)
			{
				array = immutableArray2.Array;
				if (immutableArray.array == null && array == null)
				{
					return 0;
				}
				if ((immutableArray.array == null) ^ (array == null))
				{
					throw new ArgumentException(System.SR.ArrayInitializedStateNotEqual, "other");
				}
			}
			if (array != null)
			{
				IStructuralComparable structuralComparable = immutableArray.array;
				return structuralComparable.CompareTo(array, comparer);
			}
			throw new ArgumentException(System.SR.ArrayLengthsNotEqual, "other");
		}

		private ImmutableArray<T> RemoveAtRange(ICollection<int> indicesToRemove)
		{
			ImmutableArray<T> result = this;
			result.ThrowNullRefIfNotInitialized();
			Requires.NotNull(indicesToRemove, "indicesToRemove");
			if (indicesToRemove.Count == 0)
			{
				return result;
			}
			T[] array = new T[result.Length - indicesToRemove.Count];
			int num = 0;
			int num2 = 0;
			int num3 = -1;
			foreach (int item in indicesToRemove)
			{
				int num4 = ((num3 == -1) ? item : (item - num3 - 1));
				Array.Copy(result.array, num + num2, array, num, num4);
				num2++;
				num += num4;
				num3 = item;
			}
			Array.Copy(result.array, num + num2, array, num, result.Length - (num + num2));
			return new ImmutableArray<T>(array);
		}

		internal ImmutableArray(T[] items)
		{
			array = items;
		}

		[<697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionable]
		public static bool operator ==(ImmutableArray<T> left, ImmutableArray<T> right)
		{
			return left.Equals(right);
		}

		[<697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionable]
		public static bool operator !=(ImmutableArray<T> left, ImmutableArray<T> right)
		{
			return !left.Equals(right);
		}

		public static bool operator ==(ImmutableArray<T>? left, ImmutableArray<T>? right)
		{
			return left.GetValueOrDefault().Equals(right.GetValueOrDefault());
		}

		public static bool operator !=(ImmutableArray<T>? left, ImmutableArray<T>? right)
		{
			return !left.GetValueOrDefault().Equals(right.GetValueOrDefault());
		}

		[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		public ref T ItemRef(int index)
		{
			return ref array[index];
		}

		public void CopyTo(T[] destination)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Array.Copy(immutableArray.array, 0, destination, 0, immutableArray.Length);
		}

		public void CopyTo(T[] destination, int destinationIndex)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Array.Copy(immutableArray.array, 0, destination, destinationIndex, immutableArray.Length);
		}

		public void CopyTo(int sourceIndex, T[] destination, int destinationIndex, int length)
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			Array.Copy(immutableArray.array, sourceIndex, destination, destinationIndex, length);
		}

		public Builder ToBuilder()
		{
			ImmutableArray<T> items = this;
			if (items.Length == 0)
			{
				return new Builder();
			}
			Builder builder = new Builder(items.Length);
			builder.AddRange(items);
			return builder;
		}

		public Enumerator GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowNullRefIfNotInitialized();
			return new Enumerator(immutableArray.array);
		}

		public override int GetHashCode()
		{
			ImmutableArray<T> immutableArray = this;
			if (immutableArray.array != null)
			{
				return immutableArray.array.GetHashCode();
			}
			return 0;
		}

		public override bool Equals(object obj)
		{
			if (obj is IImmutableArray immutableArray)
			{
				return array == immutableArray.Array;
			}
			return false;
		}

		[<697aa558-5a66-42ac-ac6c-097d7d165ad3>NonVersionable]
		public bool Equals(ImmutableArray<T> other)
		{
			return array == other.array;
		}

		public static ImmutableArray<T> CastUp<TDerived>(ImmutableArray<TDerived> items) where TDerived : class, T
		{
			T[] items2 = items.array;
			return new ImmutableArray<T>(items2);
		}

		public ImmutableArray<TOther> CastArray<TOther>() where TOther : class
		{
			return new ImmutableArray<TOther>((TOther[])(object)array);
		}

		public ImmutableArray<TOther> As<TOther>() where TOther : class
		{
			return new ImmutableArray<TOther>(array as TOther[]);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return EnumeratorObject.Create(immutableArray.array);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			ImmutableArray<T> immutableArray = this;
			immutableArray.ThrowInvalidOperationIfNotInitialized();
			return EnumeratorObject.Create(immutableArray.array);
		}

		internal void ThrowNullRefIfNotInitialized()
		{
			int num = array.Length;
		}

		private void ThrowInvalidOperationIfNotInitialized()
		{
			if (IsDefault)
			{
				throw new InvalidOperationException(System.SR.InvalidOperationOnDefaultArray);
			}
		}
	}
	internal sealed class ImmutableArrayBuilderDebuggerProxy<T>
	{
		private readonly ImmutableArray<T>.Builder _builder;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] A => _builder.ToArray();

		public ImmutableArrayBuilderDebuggerProxy(ImmutableArray<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			_builder = builder;
		}
	}
	internal static class ImmutableDictionary
	{
		public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>()
		{
			return ImmutableDictionary<TKey, TValue>.Empty;
		}

		public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey> keyComparer)
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer);
		}

		public static ImmutableDictionary<TKey, TValue> Create<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer);
		}

		public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return ImmutableDictionary<TKey, TValue>.Empty.AddRange(items);
		}

		public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer).AddRange(items);
		}

		public static ImmutableDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(items);
		}

		public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>()
		{
			return Create<TKey, TValue>().ToBuilder();
		}

		public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey> keyComparer)
		{
			return Create<TKey, TValue>(keyComparer).ToBuilder();
		}

		public static ImmutableDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			return Create(keyComparer, valueComparer).ToBuilder();
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			Requires.NotNull(source, "source");
			Requires.NotNull(keySelector, "keySelector");
			Requires.NotNull(elementSelector, "elementSelector");
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source.Select((TSource element) => new KeyValuePair<TKey, TValue>(keySelector(element), elementSelector(element))));
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this ImmutableDictionary<TKey, TValue>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IEqualityComparer<TKey> keyComparer)
		{
			return source.ToImmutableDictionary(keySelector, elementSelector, keyComparer, null);
		}

		public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector)
		{
			return source.ToImmutableDictionary(keySelector, (TSource v) => v, null, null);
		}

		public static ImmutableDictionary<TKey, TSource> ToImmutableDictionary<TSource, TKey>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, IEqualityComparer<TKey> keyComparer)
		{
			return source.ToImmutableDictionary(keySelector, (TSource v) => v, keyComparer, null);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector)
		{
			return source.ToImmutableDictionary(keySelector, elementSelector, null, null);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			Requires.NotNull(source, "source");
			if (source is ImmutableDictionary<TKey, TValue> immutableDictionary)
			{
				return immutableDictionary.WithComparers(keyComparer, valueComparer);
			}
			return ImmutableDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IEqualityComparer<TKey> keyComparer)
		{
			return source.ToImmutableDictionary(keyComparer, null);
		}

		public static ImmutableDictionary<TKey, TValue> ToImmutableDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source)
		{
			return source.ToImmutableDictionary(null, null);
		}

		public static bool Contains<TKey, TValue>(this IImmutableDictionary<TKey, TValue> map, TKey key, TValue value)
		{
			Requires.NotNull(map, "map");
			Requires.NotNullAllowStructs(key, "key");
			return map.Contains(new KeyValuePair<TKey, TValue>(key, value));
		}

		public static TValue GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key)
		{
			return dictionary.GetValueOrDefault(key, default(TValue));
		}

		public static TValue GetValueOrDefault<TKey, TValue>(this IImmutableDictionary<TKey, TValue> dictionary, TKey key, TValue defaultValue)
		{
			Requires.NotNull(dictionary, "dictionary");
			Requires.NotNullAllowStructs(key, "key");
			if (dictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			return defaultValue;
		}
	}
	[DebuggerTypeProxy(typeof(ImmutableDictionaryDebuggerProxy<, >))]
	[DebuggerDisplay("Count = {Count}")]
	internal sealed class ImmutableDictionary<TKey, TValue> : IImmutableDictionary<TKey, TValue>, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IImmutableDictionaryInternal<TKey, TValue>, IHashKeyCollection<TKey>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableDictionaryBuilderDebuggerProxy<, >))]
		public sealed class Builder : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection
		{
			private SortedInt32KeyNode<HashBucket> _root = SortedInt32KeyNode<HashBucket>.EmptyNode;

			private Comparers _comparers;

			private int _count;

			private ImmutableDictionary<TKey, TValue> _immutable;

			private int _version;

			private object _syncRoot;

			public IEqualityComparer<TKey> KeyComparer
			{
				get
				{
					return _comparers.KeyComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != KeyComparer)
					{
						Comparers comparers = Comparers.Get(value, ValueComparer);
						MutationInput origin = new MutationInput(SortedInt32KeyNode<HashBucket>.EmptyNode, comparers);
						MutationResult mutationResult = ImmutableDictionary<TKey, TValue>.AddRange((IEnumerable<KeyValuePair<TKey, TValue>>)this, origin, KeyCollisionBehavior.ThrowIfValueDifferent);
						_immutable = null;
						_comparers = comparers;
						_count = mutationResult.CountAdjustment;
						Root = mutationResult.Root;
					}
				}
			}

			public IEqualityComparer<TValue> ValueComparer
			{
				get
				{
					return _comparers.ValueComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != ValueComparer)
					{
						_comparers = _comparers.WithValueComparer(value);
						_immutable = null;
					}
				}
			}

			public int Count => _count;

			bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

			public IEnumerable<TKey> Keys
			{
				get
				{
					using Enumerator enumerator = GetEnumerator();
					while (enumerator.MoveNext())
					{
						yield return enumerator.Current.Key;
					}
				}
			}

			ICollection<TKey> IDictionary<TKey, TValue>.Keys => Keys.ToArray(Count);

			public IEnumerable<TValue> Values
			{
				get
				{
					using Enumerator enumerator = GetEnumerator();
					while (enumerator.MoveNext())
					{
						yield return enumerator.Current.Value;
					}
				}
			}

			ICollection<TValue> IDictionary<TKey, TValue>.Values => Values.ToArray(Count);

			bool IDictionary.IsFixedSize => false;

			bool IDictionary.IsReadOnly => false;

			ICollection IDictionary.Keys => Keys.ToArray(Count);

			ICollection IDictionary.Values => Values.ToArray(Count);

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			object IDictionary.this[object key]
			{
				get
				{
					return this[(TKey)key];
				}
				set
				{
					this[(TKey)key] = (TValue)value;
				}
			}

			internal int Version => _version;

			private MutationInput Origin => new MutationInput(Root, _comparers);

			private SortedInt32KeyNode<HashBucket> Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			public TValue this[TKey key]
			{
				get
				{
					if (TryGetValue(key, out var value))
					{
						return value;
					}
					throw new KeyNotFoundException(System.SR.Format(System.SR.Arg_KeyNotFoundWithKey, key.ToString()));
				}
				set
				{
					MutationResult result = ImmutableDictionary<TKey, TValue>.Add(key, value, KeyCollisionBehavior.SetValue, Origin);
					Apply(result);
				}
			}

			internal Builder(ImmutableDictionary<TKey, TValue> map)
			{
				Requires.NotNull(map, "map");
				_root = map._root;
				_count = map._count;
				_comparers = map._comparers;
				_immutable = map;
			}

			void IDictionary.Add(object key, object value)
			{
				Add((TKey)key, (TValue)value);
			}

			bool IDictionary.Contains(object key)
			{
				return ContainsKey((TKey)key);
			}

			IDictionaryEnumerator IDictionary.GetEnumerator()
			{
				return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
			}

			void IDictionary.Remove(object key)
			{
				Remove((TKey)key);
			}

			void ICollection.CopyTo(Array array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array.SetValue(new DictionaryEntry(current.Key, current.Value), arrayIndex++);
				}
			}

			public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items)
			{
				MutationResult result = ImmutableDictionary<TKey, TValue>.AddRange(items, Origin, KeyCollisionBehavior.ThrowIfValueDifferent);
				Apply(result);
			}

			public void RemoveRange(IEnumerable<TKey> keys)
			{
				Requires.NotNull(keys, "keys");
				foreach (TKey key in keys)
				{
					Remove(key);
				}
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(_root, this);
			}

			public TValue GetValueOrDefault(TKey key)
			{
				return GetValueOrDefault(key, default(TValue));
			}

			public TValue GetValueOrDefault(TKey key, TValue defaultValue)
			{
				Requires.NotNullAllowStructs(key, "key");
				if (TryGetValue(key, out var value))
				{
					return value;
				}
				return defaultValue;
			}

			public ImmutableDictionary<TKey, TValue> ToImmutable()
			{
				if (_immutable == null)
				{
					_immutable = ImmutableDictionary<TKey, TValue>.Wrap(_root, _comparers, _count);
				}
				return _immutable;
			}

			public void Add(TKey key, TValue value)
			{
				MutationResult result = ImmutableDictionary<TKey, TValue>.Add(key, value, KeyCollisionBehavior.ThrowIfValueDifferent, Origin);
				Apply(result);
			}

			public bool ContainsKey(TKey key)
			{
				return ImmutableDictionary<TKey, TValue>.ContainsKey(key, Origin);
			}

			public bool ContainsValue(TValue value)
			{
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						KeyValuePair<TKey, TValue> current = enumerator.Current;
						if (ValueComparer.Equals(value, current.Value))
						{
							return true;
						}
					}
				}
				return false;
			}

			public bool Remove(TKey key)
			{
				MutationResult result = ImmutableDictionary<TKey, TValue>.Remove(key, Origin);
				return Apply(result);
			}

			public bool TryGetValue(TKey key, out TValue value)
			{
				return ImmutableDictionary<TKey, TValue>.TryGetValue(key, Origin, out value);
			}

			public bool TryGetKey(TKey equalKey, out TKey actualKey)
			{
				return ImmutableDictionary<TKey, TValue>.TryGetKey(equalKey, Origin, out actualKey);
			}

			public void Add(KeyValuePair<TKey, TValue> item)
			{
				Add(item.Key, item.Value);
			}

			public void Clear()
			{
				Root = SortedInt32KeyNode<HashBucket>.EmptyNode;
				_count = 0;
			}

			public bool Contains(KeyValuePair<TKey, TValue> item)
			{
				return ImmutableDictionary<TKey, TValue>.Contains(item, Origin);
			}

			void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			public bool Remove(KeyValuePair<TKey, TValue> item)
			{
				if (Contains(item))
				{
					return Remove(item.Key);
				}
				return false;
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			private bool Apply(MutationResult result)
			{
				Root = result.Root;
				_count += result.CountAdjustment;
				return result.CountAdjustment != 0;
			}
		}

		internal sealed class Comparers : IEqualityComparer<HashBucket>, IEqualityComparer<KeyValuePair<TKey, TValue>>
		{
			internal static readonly Comparers Default = new Comparers(EqualityComparer<TKey>.Default, EqualityComparer<TValue>.Default);

			private readonly IEqualityComparer<TKey> _keyComparer;

			private readonly IEqualityComparer<TValue> _valueComparer;

			internal IEqualityComparer<TKey> KeyComparer => _keyComparer;

			internal IEqualityComparer<KeyValuePair<TKey, TValue>> KeyOnlyComparer => this;

			internal IEqualityComparer<TValue> ValueComparer => _valueComparer;

			internal IEqualityComparer<HashBucket> HashBucketEqualityComparer => this;

			internal Comparers(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				_keyComparer = keyComparer;
				_valueComparer = valueComparer;
			}

			public bool Equals(HashBucket x, HashBucket y)
			{
				if (x.AdditionalElements == y.AdditionalElements && KeyComparer.Equals(x.FirstValue.Key, y.FirstValue.Key))
				{
					return ValueComparer.Equals(x.FirstValue.Value, y.FirstValue.Value);
				}
				return false;
			}

			public int GetHashCode(HashBucket obj)
			{
				return KeyComparer.GetHashCode(obj.FirstValue.Key);
			}

			bool IEqualityComparer<KeyValuePair<TKey, TValue>>.Equals(KeyValuePair<TKey, TValue> x, KeyValuePair<TKey, TValue> y)
			{
				return _keyComparer.Equals(x.Key, y.Key);
			}

			int IEqualityComparer<KeyValuePair<TKey, TValue>>.GetHashCode(KeyValuePair<TKey, TValue> obj)
			{
				return _keyComparer.GetHashCode(obj.Key);
			}

			internal static Comparers Get(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				if (keyComparer != Default.KeyComparer || valueComparer != Default.ValueComparer)
				{
					return new Comparers(keyComparer, valueComparer);
				}
				return Default;
			}

			internal Comparers WithValueComparer(IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(valueComparer, "valueComparer");
				if (_valueComparer != valueComparer)
				{
					return Get(KeyComparer, valueComparer);
				}
				return this;
			}
		}

		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable, IEnumerator
		{
			private readonly Builder _builder;

			private SortedInt32KeyNode<HashBucket>.Enumerator _mapEnumerator;

			private HashBucket.Enumerator _bucketEnumerator;

			private int _enumeratingBuilderVersion;

			public KeyValuePair<TKey, TValue> Current
			{
				get
				{
					_mapEnumerator.ThrowIfDisposed();
					return _bucketEnumerator.Current;
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(SortedInt32KeyNode<HashBucket> root, Builder builder = null)
			{
				_builder = builder;
				_mapEnumerator = new SortedInt32KeyNode<HashBucket>.Enumerator(root);
				_bucketEnumerator = default(HashBucket.Enumerator);
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
			}

			public bool MoveNext()
			{
				ThrowIfChanged();
				if (_bucketEnumerator.MoveNext())
				{
					return true;
				}
				if (_mapEnumerator.MoveNext())
				{
					_bucketEnumerator = new HashBucket.Enumerator(_mapEnumerator.Current.Value);
					return _bucketEnumerator.MoveNext();
				}
				return false;
			}

			public void Reset()
			{
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_mapEnumerator.Reset();
				_bucketEnumerator.Dispose();
				_bucketEnumerator = default(HashBucket.Enumerator);
			}

			public void Dispose()
			{
				_mapEnumerator.Dispose();
				_bucketEnumerator.Dispose();
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}
		}

		[<d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		internal struct HashBucket : IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
		{
			internal struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable, IEnumerator
			{
				private enum Position
				{
					BeforeFirst,
					First,
					Additional,
					End
				}

				private readonly HashBucket _bucket;

				private Position _currentPosition;

				private ImmutableList<KeyValuePair<TKey, TValue>>.Enumerator _additionalEnumerator;

				object IEnumerator.Current => Current;

				public KeyValuePair<TKey, TValue> Current => _currentPosition switch
				{
					Position.First => _bucket._firstValue, 
					Position.Additional => _additionalEnumerator.Current, 
					_ => throw new InvalidOperationException(), 
				};

				internal Enumerator(HashBucket bucket)
				{
					_bucket = bucket;
					_currentPosition = Position.BeforeFirst;
					_additionalEnumerator = default(ImmutableList<KeyValuePair<TKey, TValue>>.Enumerator);
				}

				public bool MoveNext()
				{
					if (_bucket.IsEmpty)
					{
						_currentPosition = Position.End;
						return false;
					}
					switch (_currentPosition)
					{
					case Position.BeforeFirst:
						_currentPosition = Position.First;
						return true;
					case Position.First:
						if (_bucket._additionalElements.IsEmpty)
						{
							_currentPosition = Position.End;
							return false;
						}
						_currentPosition = Position.Additional;
						_additionalEnumerator = new ImmutableList<KeyValuePair<TKey, TValue>>.Enumerator(_bucket._additionalElements);
						return _additionalEnumerator.MoveNext();
					case Position.Additional:
						return _additionalEnumerator.MoveNext();
					case Position.End:
						return false;
					default:
						throw new InvalidOperationException();
					}
				}

				public void Reset()
				{
					_additionalEnumerator.Dispose();
					_currentPosition = Position.BeforeFirst;
				}

				public void Dispose()
				{
					_additionalEnumerator.Dispose();
				}
			}

			private readonly KeyValuePair<TKey, TValue> _firstValue;

			private readonly ImmutableList<KeyValuePair<TKey, TValue>>.Node _additionalElements;

			internal bool IsEmpty => _additionalElements == null;

			internal KeyValuePair<TKey, TValue> FirstValue
			{
				get
				{
					if (IsEmpty)
					{
						throw new InvalidOperationException();
					}
					return _firstValue;
				}
			}

			internal ImmutableList<KeyValuePair<TKey, TValue>>.Node AdditionalElements => _additionalElements;

			private HashBucket(KeyValuePair<TKey, TValue> firstElement, ImmutableList<KeyValuePair<TKey, TValue>>.Node additionalElements = null)
			{
				_firstValue = firstElement;
				_additionalElements = additionalElements ?? ImmutableList<KeyValuePair<TKey, TValue>>.Node.EmptyNode;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public override bool Equals(object obj)
			{
				throw new NotSupportedException();
			}

			public override int GetHashCode()
			{
				throw new NotSupportedException();
			}

			internal HashBucket Add(TKey key, TValue value, IEqualityComparer<KeyValuePair<TKey, TValue>> keyOnlyComparer, IEqualityComparer<TValue> valueComparer, KeyCollisionBehavior behavior, out OperationResult result)
			{
				KeyValuePair<TKey, TValue> keyValuePair = new KeyValuePair<TKey, TValue>(key, value);
				if (IsEmpty)
				{
					result = OperationResult.SizeChanged;
					return new HashBucket(keyValuePair);
				}
				if (keyOnlyComparer.Equals(keyValuePair, _firstValue))
				{
					switch (behavior)
					{
					case KeyCollisionBehavior.SetValue:
						result = OperationResult.AppliedWithoutSizeChange;
						return new HashBucket(keyValuePair, _additionalElements);
					case KeyCollisionBehavior.Skip:
						result = OperationResult.NoChangeRequired;
						return this;
					case KeyCollisionBehavior.ThrowIfValueDifferent:
					{
						KeyValuePair<TKey, TValue> firstValue = _firstValue;
						if (!valueComparer.Equals(firstValue.Value, value))
						{
							throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
						}
						result = OperationResult.NoChangeRequired;
						return this;
					}
					case KeyCollisionBehavior.ThrowAlways:
						throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
					default:
						throw new InvalidOperationException();
					}
				}
				int num = _additionalElements.IndexOf(keyValuePair, keyOnlyComparer);
				if (num < 0)
				{
					result = OperationResult.SizeChanged;
					return new HashBucket(_firstValue, _additionalElements.Add(keyValuePair));
				}
				switch (behavior)
				{
				case KeyCollisionBehavior.SetValue:
					result = OperationResult.AppliedWithoutSizeChange;
					return new HashBucket(_firstValue, _additionalElements.ReplaceAt(num, keyValuePair));
				case KeyCollisionBehavior.Skip:
					result = OperationResult.NoChangeRequired;
					return this;
				case KeyCollisionBehavior.ThrowIfValueDifferent:
				{
					KeyValuePair<TKey, TValue> firstValue = _additionalElements.ItemRef(num);
					if (!valueComparer.Equals(firstValue.Value, value))
					{
						throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
					}
					result = OperationResult.NoChangeRequired;
					return this;
				}
				case KeyCollisionBehavior.ThrowAlways:
					throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
				default:
					throw new InvalidOperationException();
				}
			}

			internal HashBucket Remove(TKey key, IEqualityComparer<KeyValuePair<TKey, TValue>> keyOnlyComparer, out OperationResult result)
			{
				if (IsEmpty)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				KeyValuePair<TKey, TValue> keyValuePair = new KeyValuePair<TKey, TValue>(key, default(TValue));
				if (keyOnlyComparer.Equals(_firstValue, keyValuePair))
				{
					if (_additionalElements.IsEmpty)
					{
						result = OperationResult.SizeChanged;
						return default(HashBucket);
					}
					int count = _additionalElements.Left.Count;
					result = OperationResult.SizeChanged;
					return new HashBucket(_additionalElements.Key, _additionalElements.RemoveAt(count));
				}
				int num = _additionalElements.IndexOf(keyValuePair, keyOnlyComparer);
				if (num < 0)
				{
					result = OperationResult.NoChangeRequired;
					return this;
				}
				result = OperationResult.SizeChanged;
				return new HashBucket(_firstValue, _additionalElements.RemoveAt(num));
			}

			internal bool TryGetValue(TKey key, Comparers comparers, out TValue value)
			{
				if (IsEmpty)
				{
					value = default(TValue);
					return false;
				}
				IEqualityComparer<TKey> keyComparer = comparers.KeyComparer;
				KeyValuePair<TKey, TValue> firstValue = _firstValue;
				if (keyComparer.Equals(firstValue.Key, key))
				{
					firstValue = _firstValue;
					value = firstValue.Value;
					return true;
				}
				KeyValuePair<TKey, TValue> item = new KeyValuePair<TKey, TValue>(key, default(TValue));
				int num = _additionalElements.IndexOf(item, comparers.KeyOnlyComparer);
				if (num < 0)
				{
					value = default(TValue);
					return false;
				}
				firstValue = _additionalElements.ItemRef(num);
				value = firstValue.Value;
				return true;
			}

			internal bool TryGetKey(TKey equalKey, Comparers comparers, out TKey actualKey)
			{
				if (IsEmpty)
				{
					actualKey = equalKey;
					return false;
				}
				IEqualityComparer<TKey> keyComparer = comparers.KeyComparer;
				KeyValuePair<TKey, TValue> firstValue = _firstValue;
				if (keyComparer.Equals(firstValue.Key, equalKey))
				{
					firstValue = _firstValue;
					actualKey = firstValue.Key;
					return true;
				}
				KeyValuePair<TKey, TValue> item = new KeyValuePair<TKey, TValue>(equalKey, default(TValue));
				int num = _additionalElements.IndexOf(item, comparers.KeyOnlyComparer);
				if (num < 0)
				{
					actualKey = equalKey;
					return false;
				}
				firstValue = _additionalElements.ItemRef(num);
				actualKey = firstValue.Key;
				return true;
			}

			internal void Freeze()
			{
				if (_additionalElements != null)
				{
					_additionalElements.Freeze();
				}
			}
		}

		[<d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		private struct MutationInput
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly Comparers _comparers;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal Comparers Comparers => _comparers;

			internal IEqualityComparer<TKey> KeyComparer => _comparers.KeyComparer;

			internal IEqualityComparer<KeyValuePair<TKey, TValue>> KeyOnlyComparer => _comparers.KeyOnlyComparer;

			internal IEqualityComparer<TValue> ValueComparer => _comparers.ValueComparer;

			internal IEqualityComparer<HashBucket> HashBucketComparer => _comparers.HashBucketEqualityComparer;

			internal MutationInput(SortedInt32KeyNode<HashBucket> root, Comparers comparers)
			{
				_root = root;
				_comparers = comparers;
			}

			internal MutationInput(ImmutableDictionary<TKey, TValue> map)
			{
				_root = map._root;
				_comparers = map._comparers;
			}
		}

		[<d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		private struct MutationResult
		{
			private readonly SortedInt32KeyNode<HashBucket> _root;

			private readonly int _countAdjustment;

			internal SortedInt32KeyNode<HashBucket> Root => _root;

			internal int CountAdjustment => _countAdjustment;

			internal MutationResult(MutationInput unchangedInput)
			{
				_root = unchangedInput.Root;
				_countAdjustment = 0;
			}

			internal MutationResult(SortedInt32KeyNode<HashBucket> root, int countAdjustment)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_countAdjustment = countAdjustment;
			}

			internal ImmutableDictionary<TKey, TValue> Finalize(ImmutableDictionary<TKey, TValue> priorMap)
			{
				Requires.NotNull(priorMap, "priorMap");
				return priorMap.Wrap(Root, priorMap._count + CountAdjustment);
			}
		}

		internal enum KeyCollisionBehavior
		{
			SetValue,
			Skip,
			ThrowIfValueDifferent,
			ThrowAlways
		}

		internal enum OperationResult
		{
			AppliedWithoutSizeChange,
			SizeChanged,
			NoChangeRequired
		}

		public static readonly ImmutableDictionary<TKey, TValue> Empty = new ImmutableDictionary<TKey, TValue>();

		private static readonly Action<KeyValuePair<int, HashBucket>> s_FreezeBucketAction = delegate(KeyValuePair<int, HashBucket> kv)
		{
			kv.Value.Freeze();
		};

		private readonly int _count;

		private readonly SortedInt32KeyNode<HashBucket> _root;

		private readonly Comparers _comparers;

		public int Count => _count;

		public bool IsEmpty => Count == 0;

		public IEqualityComparer<TKey> KeyComparer => _comparers.KeyComparer;

		public IEqualityComparer<TValue> ValueComparer => _comparers.ValueComparer;

		public IEnumerable<TKey> Keys
		{
			get
			{
				foreach (KeyValuePair<int, HashBucket> item in _root)
				{
					foreach (KeyValuePair<TKey, TValue> item2 in item.Value)
					{
						yield return item2.Key;
					}
				}
			}
		}

		public IEnumerable<TValue> Values
		{
			get
			{
				foreach (KeyValuePair<int, HashBucket> item in _root)
				{
					foreach (KeyValuePair<TKey, TValue> item2 in item.Value)
					{
						yield return item2.Value;
					}
				}
			}
		}

		ICollection<TKey> IDictionary<TKey, TValue>.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection<TValue> IDictionary<TKey, TValue>.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		private MutationInput Origin => new MutationInput(this);

		public TValue this[TKey key]
		{
			get
			{
				Requires.NotNullAllowStructs(key, "key");
				if (TryGetValue(key, out var value))
				{
					return value;
				}
				throw new KeyNotFoundException();
			}
		}

		TValue IDictionary<TKey, TValue>.this[TKey key]
		{
			get
			{
				return this[key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;

		bool IDictionary.IsFixedSize => true;

		bool IDictionary.IsReadOnly => true;

		ICollection IDictionary.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection IDictionary.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		internal SortedInt32KeyNode<HashBucket> Root => _root;

		object IDictionary.this[object key]
		{
			get
			{
				return this[(TKey)key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		private ImmutableDictionary(SortedInt32KeyNode<HashBucket> root, Comparers comparers, int count)
			: this(Requires.NotNullPassthrough(comparers, "comparers"))
		{
			Requires.NotNull(root, "root");
			root.Freeze(s_FreezeBucketAction);
			_root = root;
			_count = count;
		}

		private ImmutableDictionary(Comparers comparers = null)
		{
			_comparers = comparers ?? Comparers.Get(EqualityComparer<TKey>.Default, EqualityComparer<TValue>.Default);
			_root = SortedInt32KeyNode<HashBucket>.EmptyNode;
		}

		public ImmutableDictionary<TKey, TValue> Clear()
		{
			if (!IsEmpty)
			{
				return EmptyWithComparers(_comparers);
			}
			return this;
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Clear()
		{
			return Clear();
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableDictionary<TKey, TValue> Add(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return Add(key, value, KeyCollisionBehavior.ThrowIfValueDifferent, Origin).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
		{
			Requires.NotNull(pairs, "pairs");
			return AddRange(pairs, avoidToHashMap: false);
		}

		public ImmutableDictionary<TKey, TValue> SetItem(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return Add(key, value, KeyCollisionBehavior.SetValue, Origin).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			Requires.NotNull(items, "items");
			return AddRange(items, Origin, KeyCollisionBehavior.SetValue).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> Remove(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return Remove(key, Origin).Finalize(this);
		}

		public ImmutableDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys)
		{
			Requires.NotNull(keys, "keys");
			int num = _count;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = _root;
			foreach (TKey key in keys)
			{
				int hashCode = KeyComparer.GetHashCode(key);
				if (sortedInt32KeyNode.TryGetValue(hashCode, out var value))
				{
					OperationResult result;
					HashBucket newBucket = value.Remove(key, _comparers.KeyOnlyComparer, out result);
					sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, hashCode, newBucket, _comparers.HashBucketEqualityComparer);
					if (result == OperationResult.SizeChanged)
					{
						num--;
					}
				}
			}
			return Wrap(sortedInt32KeyNode, num);
		}

		public bool ContainsKey(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return ContainsKey(key, Origin);
		}

		public bool Contains(KeyValuePair<TKey, TValue> pair)
		{
			return Contains(pair, Origin);
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return TryGetValue(key, Origin, out value);
		}

		public bool TryGetKey(TKey equalKey, out TKey actualKey)
		{
			Requires.NotNullAllowStructs(equalKey, "equalKey");
			return TryGetKey(equalKey, Origin, out actualKey);
		}

		public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			if (keyComparer == null)
			{
				keyComparer = EqualityComparer<TKey>.Default;
			}
			if (valueComparer == null)
			{
				valueComparer = EqualityComparer<TValue>.Default;
			}
			if (KeyComparer == keyComparer)
			{
				if (ValueComparer == valueComparer)
				{
					return this;
				}
				Comparers comparers = _comparers.WithValueComparer(valueComparer);
				return new ImmutableDictionary<TKey, TValue>(_root, comparers, _count);
			}
			Comparers comparers2 = Comparers.Get(keyComparer, valueComparer);
			ImmutableDictionary<TKey, TValue> immutableDictionary = new ImmutableDictionary<TKey, TValue>(comparers2);
			return immutableDictionary.AddRange(this, avoidToHashMap: true);
		}

		public ImmutableDictionary<TKey, TValue> WithComparers(IEqualityComparer<TKey> keyComparer)
		{
			return WithComparers(keyComparer, _comparers.ValueComparer);
		}

		public bool ContainsValue(TValue value)
		{
			using (Enumerator enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					if (ValueComparer.Equals(value, current.Value))
					{
						return true;
					}
				}
			}
			return false;
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(_root);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			return Add(key, value);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItem(TKey key, TValue value)
		{
			return SetItem(key, value);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return SetItems(items);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
		{
			return AddRange(pairs);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.RemoveRange(IEnumerable<TKey> keys)
		{
			return RemoveRange(keys);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Remove(TKey key)
		{
			return Remove(key);
		}

		void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary<TKey, TValue>.Remove(TKey key)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<TKey, TValue> current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		void IDictionary.Add(object key, object value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary.Contains(object key)
		{
			return ContainsKey((TKey)key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
		}

		void IDictionary.Remove(object key)
		{
			throw new NotSupportedException();
		}

		void IDictionary.Clear()
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<TKey, TValue> current = enumerator.Current;
				array.SetValue(new DictionaryEntry(current.Key, current.Value), arrayIndex++);
			}
		}

		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<KeyValuePair<TKey, TValue>>().GetEnumerator();
		}

		[ExcludeFromCodeCoverage]
		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private static ImmutableDictionary<TKey, TValue> EmptyWithComparers(Comparers comparers)
		{
			Requires.NotNull(comparers, "comparers");
			if (Empty._comparers != comparers)
			{
				return new ImmutableDictionary<TKey, TValue>(comparers);
			}
			return Empty;
		}

		private static bool TryCastToImmutableMap(IEnumerable<KeyValuePair<TKey, TValue>> sequence, out ImmutableDictionary<TKey, TValue> other)
		{
			other = sequence as ImmutableDictionary<TKey, TValue>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private static bool ContainsKey(TKey key, MutationInput origin)
		{
			int hashCode = origin.KeyComparer.GetHashCode(key);
			TValue value2;
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				return value.TryGetValue(key, origin.Comparers, out value2);
			}
			return false;
		}

		private static bool Contains(KeyValuePair<TKey, TValue> keyValuePair, MutationInput origin)
		{
			int hashCode = origin.KeyComparer.GetHashCode(keyValuePair.Key);
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				if (value.TryGetValue(keyValuePair.Key, origin.Comparers, out var value2))
				{
					return origin.ValueComparer.Equals(value2, keyValuePair.Value);
				}
				return false;
			}
			return false;
		}

		private static bool TryGetValue(TKey key, MutationInput origin, out TValue value)
		{
			int hashCode = origin.KeyComparer.GetHashCode(key);
			if (origin.Root.TryGetValue(hashCode, out var value2))
			{
				return value2.TryGetValue(key, origin.Comparers, out value);
			}
			value = default(TValue);
			return false;
		}

		private static bool TryGetKey(TKey equalKey, MutationInput origin, out TKey actualKey)
		{
			int hashCode = origin.KeyComparer.GetHashCode(equalKey);
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				return value.TryGetKey(equalKey, origin.Comparers, out actualKey);
			}
			actualKey = equalKey;
			return false;
		}

		private static MutationResult Add(TKey key, TValue value, KeyCollisionBehavior behavior, MutationInput origin)
		{
			Requires.NotNullAllowStructs(key, "key");
			int hashCode = origin.KeyComparer.GetHashCode(key);
			OperationResult result;
			HashBucket newBucket = origin.Root.GetValueOrDefault(hashCode).Add(key, value, origin.KeyOnlyComparer, origin.ValueComparer, behavior, out result);
			if (result == OperationResult.NoChangeRequired)
			{
				return new MutationResult(origin);
			}
			SortedInt32KeyNode<HashBucket> root = UpdateRoot(origin.Root, hashCode, newBucket, origin.HashBucketComparer);
			return new MutationResult(root, (result == OperationResult.SizeChanged) ? 1 : 0);
		}

		private static MutationResult AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items, MutationInput origin, KeyCollisionBehavior collisionBehavior = KeyCollisionBehavior.ThrowIfValueDifferent)
		{
			Requires.NotNull(items, "items");
			int num = 0;
			SortedInt32KeyNode<HashBucket> sortedInt32KeyNode = origin.Root;
			foreach (KeyValuePair<TKey, TValue> item in items)
			{
				int hashCode = origin.KeyComparer.GetHashCode(item.Key);
				OperationResult result;
				HashBucket newBucket = sortedInt32KeyNode.GetValueOrDefault(hashCode).Add(item.Key, item.Value, origin.KeyOnlyComparer, origin.ValueComparer, collisionBehavior, out result);
				sortedInt32KeyNode = UpdateRoot(sortedInt32KeyNode, hashCode, newBucket, origin.HashBucketComparer);
				if (result == OperationResult.SizeChanged)
				{
					num++;
				}
			}
			return new MutationResult(sortedInt32KeyNode, num);
		}

		private static MutationResult Remove(TKey key, MutationInput origin)
		{
			int hashCode = origin.KeyComparer.GetHashCode(key);
			if (origin.Root.TryGetValue(hashCode, out var value))
			{
				OperationResult result;
				SortedInt32KeyNode<HashBucket> root = UpdateRoot(origin.Root, hashCode, value.Remove(key, origin.KeyOnlyComparer, out result), origin.HashBucketComparer);
				return new MutationResult(root, (result == OperationResult.SizeChanged) ? (-1) : 0);
			}
			return new MutationResult(origin);
		}

		private static SortedInt32KeyNode<HashBucket> UpdateRoot(SortedInt32KeyNode<HashBucket> root, int hashCode, HashBucket newBucket, IEqualityComparer<HashBucket> hashBucketComparer)
		{
			bool mutated;
			if (newBucket.IsEmpty)
			{
				return root.Remove(hashCode, out mutated);
			}
			bool replacedExistingValue;
			return root.SetItem(hashCode, newBucket, hashBucketComparer, out replacedExistingValue, out mutated);
		}

		private static ImmutableDictionary<TKey, TValue> Wrap(SortedInt32KeyNode<HashBucket> root, Comparers comparers, int count)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(comparers, "comparers");
			Requires.Range(count >= 0, "count");
			return new ImmutableDictionary<TKey, TValue>(root, comparers, count);
		}

		private ImmutableDictionary<TKey, TValue> Wrap(SortedInt32KeyNode<HashBucket> root, int adjustedCountIfDifferentRoot)
		{
			if (root == null)
			{
				return Clear();
			}
			if (_root != root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableDictionary<TKey, TValue>(root, _comparers, adjustedCountIfDifferentRoot);
				}
				return Clear();
			}
			return this;
		}

		private ImmutableDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs, bool avoidToHashMap)
		{
			Requires.NotNull(pairs, "pairs");
			if (IsEmpty && !avoidToHashMap && TryCastToImmutableMap(pairs, out var other))
			{
				return other.WithComparers(KeyComparer, ValueComparer);
			}
			return AddRange(pairs, Origin).Finalize(this);
		}
	}
	internal class ImmutableDictionaryBuilderDebuggerProxy<TKey, TValue>
	{
		private readonly ImmutableDictionary<TKey, TValue>.Builder _map;

		private KeyValuePair<TKey, TValue>[] _contents;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public KeyValuePair<TKey, TValue>[] Contents
		{
			get
			{
				if (_contents == null)
				{
					_contents = _map.ToArray(_map.Count);
				}
				return _contents;
			}
		}

		public ImmutableDictionaryBuilderDebuggerProxy(ImmutableDictionary<TKey, TValue>.Builder map)
		{
			Requires.NotNull(map, "map");
			_map = map;
		}
	}
	internal class ImmutableDictionaryDebuggerProxy<TKey, TValue> : ImmutableEnumerableDebuggerProxy<KeyValuePair<TKey, TValue>>
	{
		public ImmutableDictionaryDebuggerProxy(IImmutableDictionary<TKey, TValue> dictionary)
			: base((IEnumerable<KeyValuePair<TKey, TValue>>)dictionary)
		{
		}
	}
	internal class ImmutableEnumerableDebuggerProxy<T>
	{
		private readonly IEnumerable<T> _enumerable;

		private T[] _cachedContents;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Contents => _cachedContents ?? (_cachedContents = _enumerable.ToArray());

		public ImmutableEnumerableDebuggerProxy(IEnumerable<T> enumerable)
		{
			Requires.NotNull(enumerable, "enumerable");
			_enumerable = enumerable;
		}
	}
	internal static class ImmutableExtensions
	{
		private class ListOfTWrapper<T> : IOrderedCollection<T>, IEnumerable<T>, IEnumerable
		{
			private readonly IList<T> _collection;

			public int Count => _collection.Count;

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

			internal ListOfTWrapper(IList<T> collection)
			{
				Requires.NotNull(collection, "collection");
				_collection = collection;
			}

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

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		private class FallbackWrapper<T> : IOrderedCollection<T>, IEnumerable<T>, IEnumerable
		{
			private readonly IEnumerable<T> _sequence;

			private IList<T> _collection;

			public int Count
			{
				get
				{
					if (_collection == null)
					{
						if (_sequence.TryGetCount(out var count))
						{
							return count;
						}
						_collection = _sequence.ToArray();
					}
					return _collection.Count;
				}
			}

			public T this[int index]
			{
				get
				{
					if (_collection == null)
					{
						_collection = _sequence.ToArray();
					}
					return _collection[index];
				}
			}

			internal FallbackWrapper(IEnumerable<T> sequence)
			{
				Requires.NotNull(sequence, "sequence");
				_sequence = sequence;
			}

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

			[ExcludeFromCodeCoverage]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		internal static bool IsValueType<T>()
		{
			if (default(T) != null)
			{
				return true;
			}
			Type typeFromHandle = typeof(T);
			if (typeFromHandle.IsConstructedGenericType && typeFromHandle.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				return true;
			}
			return false;
		}

		internal static IOrderedCollection<T> AsOrderedCollection<T>(this IEnumerable<T> sequence)
		{
			Requires.NotNull(sequence, "sequence");
			if (sequence is IOrderedCollection<T> result)
			{
				return result;
			}
			if (sequence is IList<T> collection)
			{
				return new ListOfTWrapper<T>(collection);
			}
			return new FallbackWrapper<T>(sequence);
		}

		internal static void ClearFastWhenEmpty<T>(this Stack<T> stack)
		{
			if (stack.Count > 0)
			{
				stack.Clear();
			}
		}

		internal static DisposableEnumeratorAdapter<T, TEnumerator> GetEnumerableDisposable<T, TEnumerator>(this IEnumerable<T> enumerable) where TEnumerator : struct, IStrongEnumerator<T>, IEnumerator<T>
		{
			Requires.NotNull(enumerable, "enumerable");
			if (enumerable is IStrongEnumerable<T, TEnumerator> strongEnumerable)
			{
				return new DisposableEnumeratorAdapter<T, TEnumerator>(strongEnumerable.GetEnumerator());
			}
			return new DisposableEnumeratorAdapter<T, TEnumerator>(enumerable.GetEnumerator());
		}

		internal static bool TryGetCount<T>(this IEnumerable<T> sequence, out int count)
		{
			return ((IEnumerable)sequence).TryGetCount<T>(out count);
		}

		internal static bool TryGetCount<T>(this IEnumerable sequence, out int count)
		{
			if (sequence is ICollection collection)
			{
				count = collection.Count;
				return true;
			}
			if (sequence is ICollection<T> collection2)
			{
				count = collection2.Count;
				return true;
			}
			if (sequence is IReadOnlyCollection<T> readOnlyCollection)
			{
				count = readOnlyCollection.Count;
				return true;
			}
			count = 0;
			return false;
		}

		internal static int GetCount<T>(ref IEnumerable<T> sequence)
		{
			if (!sequence.TryGetCount(out var count))
			{
				List<T> list = sequence.ToList();
				count = list.Count;
				sequence = list;
			}
			return count;
		}

		internal static bool TryCopyTo<T>(this IEnumerable<T> sequence, T[] array, int arrayIndex)
		{
			if (sequence is IList<T>)
			{
				if (sequence is List<T> list2)
				{
					list2.CopyTo(array, arrayIndex);
					return true;
				}
				if (sequence.GetType() == typeof(T[]))
				{
					T[] array2 = (T[])sequence;
					Array.Copy(array2, 0, array, arrayIndex, array2.Length);
					return true;
				}
				if (sequence is ImmutableArray<T> immutableArray)
				{
					Array.Copy(immutableArray.array, 0, array, arrayIndex, immutableArray.Length);
					return true;
				}
			}
			return false;
		}

		internal static T[] ToArray<T>(this IEnumerable<T> sequence, int count)
		{
			Requires.NotNull(sequence, "sequence");
			Requires.Range(count >= 0, "count");
			if (count == 0)
			{
				return ImmutableArray<T>.Empty.array;
			}
			T[] array = new T[count];
			if (!sequence.TryCopyTo(array, 0))
			{
				int num = 0;
				foreach (T item in sequence)
				{
					Requires.Argument(num < count);
					array[num++] = item;
				}
				Requires.Argument(num == count);
			}
			return array;
		}
	}
	internal static class ImmutableHashSet
	{
		public static ImmutableHashSet<T> Create<T>()
		{
			return ImmutableHashSet<T>.Empty;
		}

		public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer);
		}

		public static ImmutableHashSet<T> Create<T>(T item)
		{
			return ImmutableHashSet<T>.Empty.Add(item);
		}

		public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer, T item)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer).Add(item);
		}

		public static ImmutableHashSet<T> CreateRange<T>(IEnumerable<T> items)
		{
			return ImmutableHashSet<T>.Empty.Union(items);
		}

		public static ImmutableHashSet<T> CreateRange<T>(IEqualityComparer<T> equalityComparer, IEnumerable<T> items)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer).Union(items);
		}

		public static ImmutableHashSet<T> Create<T>(params T[] items)
		{
			return ImmutableHashSet<T>.Empty.Union(items);
		}

		public static ImmutableHashSet<T> Create<T>(IEqualityComparer<T> equalityComparer, params T[] items)
		{
			return ImmutableHashSet<T>.Empty.WithComparer(equalityComparer).Union(items);
		}

		public static ImmutableHashSet<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableHashSet<T>.Builder CreateBuilder<T>(IEqualityComparer<T> equalityComparer)
		{
			return Create(equalityComparer).ToBuilder();
		}

		public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> equalityComparer)
		{
			if (source is ImmutableHashSet<TSource> immutableHashSet)
			{
				return immutableHashSet.WithComparer(equalityComparer);
			}
			return ImmutableHashSet<TSource>.Empty.WithComparer(equalityComparer).Union(source);
		}

		public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this ImmutableHashSet<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static ImmutableHashSet<TSource> ToImmutableHashSet<TSource>(this IEnumerable<TSource> source)
		{
			return source.ToImmutableHashSet(null);
		}
	}
	internal static class ImmutableInterlocked
	{
		public static bool Update<T>(ref T location, Func<T, T> transformer) where T : class
		{
			Requires.NotNull(transformer, "transformer");
			T val = Volatile.Read(ref location);
			bool flag;
			do
			{
				T val2 = transformer(val);
				if (val == val2)
				{
					return false;
				}
				T val3 = Interlocked.CompareExchange(ref location, val2, val);
				flag = val == val3;
				val = val3;
			}
			while (!flag);
			return true;
		}

		public static bool Update<T, TArg>(ref T location, Func<T, TArg, T> transformer, TArg transformerArgument) where T : class
		{
			Requires.NotNull(transformer, "transformer");
			T val = Volatile.Read(ref location);
			bool flag;
			do
			{
				T val2 = transformer(val, transformerArgument);
				if (val == val2)
				{
					return false;
				}
				T val3 = Interlocked.CompareExchange(ref location, val2, val);
				flag = val == val3;
				val = val3;
			}
			while (!flag);
			return true;
		}

		public static ImmutableArray<T> InterlockedExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value)
		{
			return new ImmutableArray<T>(Interlocked.Exchange(ref location.array, value.array));
		}

		public static ImmutableArray<T> InterlockedCompareExchange<T>(ref ImmutableArray<T> location, ImmutableArray<T> value, ImmutableArray<T> comparand)
		{
			return new ImmutableArray<T>(Interlocked.CompareExchange(ref location.array, value.array, comparand.array));
		}

		public static bool InterlockedInitialize<T>(ref ImmutableArray<T> location, ImmutableArray<T> value)
		{
			return InterlockedCompareExchange(ref location, value, default(ImmutableArray<T>)).IsDefault;
		}

		public static TValue GetOrAdd<TKey, TValue, TArg>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TArg, TValue> valueFactory, TArg factoryArgument)
		{
			Requires.NotNull(valueFactory, "valueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			Requires.NotNull(immutableDictionary, "location");
			if (immutableDictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			value = valueFactory(key, factoryArgument);
			return GetOrAdd(ref location, key, value);
		}

		public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> valueFactory)
		{
			Requires.NotNull(valueFactory, "valueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			Requires.NotNull(immutableDictionary, "location");
			if (immutableDictionary.TryGetValue(key, out var value))
			{
				return value;
			}
			value = valueFactory(key);
			return GetOrAdd(ref location, key, value);
		}

		public static TValue GetOrAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value)
		{
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (immutableDictionary.TryGetValue(key, out var value2))
				{
					return value2;
				}
				ImmutableDictionary<TKey, TValue> value3 = immutableDictionary.Add(key, value);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value3, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return value;
		}

		public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, Func<TKey, TValue> addValueFactory, Func<TKey, TValue, TValue> updateValueFactory)
		{
			Requires.NotNull(addValueFactory, "addValueFactory");
			Requires.NotNull(updateValueFactory, "updateValueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			TValue val;
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				val = ((!immutableDictionary.TryGetValue(key, out var value)) ? addValueFactory(key) : updateValueFactory(key, value));
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.SetItem(key, val);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return val;
		}

		public static TValue AddOrUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue addValue, Func<TKey, TValue, TValue> updateValueFactory)
		{
			Requires.NotNull(updateValueFactory, "updateValueFactory");
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			TValue val;
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				val = ((!immutableDictionary.TryGetValue(key, out var value)) ? addValue : updateValueFactory(key, value));
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.SetItem(key, val);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return val;
		}

		public static bool TryAdd<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue value)
		{
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (immutableDictionary.ContainsKey(key))
				{
					return false;
				}
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.Add(key, value);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return true;
		}

		public static bool TryUpdate<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, TValue newValue, TValue comparisonValue)
		{
			EqualityComparer<TValue> @default = EqualityComparer<TValue>.Default;
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (!immutableDictionary.TryGetValue(key, out var value) || !@default.Equals(value, comparisonValue))
				{
					return false;
				}
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.SetItem(key, newValue);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return true;
		}

		public static bool TryRemove<TKey, TValue>(ref ImmutableDictionary<TKey, TValue> location, TKey key, out TValue value)
		{
			ImmutableDictionary<TKey, TValue> immutableDictionary = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableDictionary, "location");
				if (!immutableDictionary.TryGetValue(key, out value))
				{
					return false;
				}
				ImmutableDictionary<TKey, TValue> value2 = immutableDictionary.Remove(key);
				ImmutableDictionary<TKey, TValue> immutableDictionary2 = Interlocked.CompareExchange(ref location, value2, immutableDictionary);
				flag = immutableDictionary == immutableDictionary2;
				immutableDictionary = immutableDictionary2;
			}
			while (!flag);
			return true;
		}

		public static bool TryPop<T>(ref ImmutableStack<T> location, out T value)
		{
			ImmutableStack<T> immutableStack = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableStack, "location");
				if (immutableStack.IsEmpty)
				{
					value = default(T);
					return false;
				}
				ImmutableStack<T> value2 = immutableStack.Pop(out value);
				ImmutableStack<T> immutableStack2 = Interlocked.CompareExchange(ref location, value2, immutableStack);
				flag = immutableStack == immutableStack2;
				immutableStack = immutableStack2;
			}
			while (!flag);
			return true;
		}

		public static void Push<T>(ref ImmutableStack<T> location, T value)
		{
			ImmutableStack<T> immutableStack = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableStack, "location");
				ImmutableStack<T> value2 = immutableStack.Push(value);
				ImmutableStack<T> immutableStack2 = Interlocked.CompareExchange(ref location, value2, immutableStack);
				flag = immutableStack == immutableStack2;
				immutableStack = immutableStack2;
			}
			while (!flag);
		}

		public static bool TryDequeue<T>(ref ImmutableQueue<T> location, out T value)
		{
			ImmutableQueue<T> immutableQueue = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableQueue, "location");
				if (immutableQueue.IsEmpty)
				{
					value = default(T);
					return false;
				}
				ImmutableQueue<T> value2 = immutableQueue.Dequeue(out value);
				ImmutableQueue<T> immutableQueue2 = Interlocked.CompareExchange(ref location, value2, immutableQueue);
				flag = immutableQueue == immutableQueue2;
				immutableQueue = immutableQueue2;
			}
			while (!flag);
			return true;
		}

		public static void Enqueue<T>(ref ImmutableQueue<T> location, T value)
		{
			ImmutableQueue<T> immutableQueue = Volatile.Read(ref location);
			bool flag;
			do
			{
				Requires.NotNull(immutableQueue, "location");
				ImmutableQueue<T> value2 = immutableQueue.Enqueue(value);
				ImmutableQueue<T> immutableQueue2 = Interlocked.CompareExchange(ref location, value2, immutableQueue);
				flag = immutableQueue == immutableQueue2;
				immutableQueue = immutableQueue2;
			}
			while (!flag);
		}
	}
	internal static class ImmutableList
	{
		public static ImmutableList<T> Create<T>()
		{
			return ImmutableList<T>.Empty;
		}

		public static ImmutableList<T> Create<T>(T item)
		{
			return ImmutableList<T>.Empty.Add(item);
		}

		public static ImmutableList<T> CreateRange<T>(IEnumerable<T> items)
		{
			return ImmutableList<T>.Empty.AddRange(items);
		}

		public static ImmutableList<T> Create<T>(params T[] items)
		{
			return ImmutableList<T>.Empty.AddRange(items);
		}

		public static ImmutableList<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableList<TSource> ToImmutableList<TSource>(this IEnumerable<TSource> source)
		{
			if (source is ImmutableList<TSource> result)
			{
				return result;
			}
			return ImmutableList<TSource>.Empty.AddRange(source);
		}

		public static ImmutableList<TSource> ToImmutableList<TSource>(this ImmutableList<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static IImmutableList<T> Replace<T>(this IImmutableList<T> list, T oldValue, T newValue)
		{
			Requires.NotNull(list, "list");
			return list.Replace(oldValue, newValue, EqualityComparer<T>.Default);
		}

		public static IImmutableList<T> Remove<T>(this IImmutableList<T> list, T value)
		{
			Requires.NotNull(list, "list");
			return list.Remove(value, EqualityComparer<T>.Default);
		}

		public static IImmutableList<T> RemoveRange<T>(this IImmutableList<T> list, IEnumerable<T> items)
		{
			Requires.NotNull(list, "list");
			return list.RemoveRange(items, EqualityComparer<T>.Default);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, 0, list.Count, EqualityComparer<T>.Default);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T> equalityComparer)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, 0, list.Count, equalityComparer);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, startIndex, list.Count - startIndex, EqualityComparer<T>.Default);
		}

		public static int IndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count)
		{
			Requires.NotNull(list, "list");
			return list.IndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item)
		{
			Requires.NotNull(list, "list");
			if (list.Count == 0)
			{
				return -1;
			}
			return list.LastIndexOf(item, list.Count - 1, list.Count, EqualityComparer<T>.Default);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item, IEqualityComparer<T> equalityComparer)
		{
			Requires.NotNull(list, "list");
			if (list.Count == 0)
			{
				return -1;
			}
			return list.LastIndexOf(item, list.Count - 1, list.Count, equalityComparer);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex)
		{
			Requires.NotNull(list, "list");
			if (list.Count == 0 && startIndex == 0)
			{
				return -1;
			}
			return list.LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
		}

		public static int LastIndexOf<T>(this IImmutableList<T> list, T item, int startIndex, int count)
		{
			Requires.NotNull(list, "list");
			return list.LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
		}
	}
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	[DebuggerDisplay("Count = {Count}")]
	internal sealed class ImmutableList<T> : IImmutableList<T>, IReadOnlyList<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, IList<T>, ICollection<T>, IList, ICollection, IOrderedCollection<T>, IImmutableListQueries<T>, IStrongEnumerable<T, ImmutableList<T>.Enumerator>
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableListBuilderDebuggerProxy<>))]
		public sealed class Builder : IList<T>, ICollection<T>, IEnumerable<T>, IEnumerable, IList, ICollection, IOrderedCollection<T>, IImmutableListQueries<T>, IReadOnlyList<T>, IReadOnlyCollection<T>
		{
			private Node _root = Node.EmptyNode;

			private ImmutableList<T> _immutable;

			private int _version;

			private object _syncRoot;

			public int Count => Root.Count;

			bool ICollection<T>.IsReadOnly => false;

			internal int Version => _version;

			internal Node Root
			{
				get
				{
					return _root;
				}
				private set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			public T this[int index]
			{
				get
				{
					return Root.ItemRef(index);
				}
				set
				{
					Root = Root.ReplaceAt(index, value);
				}
			}

			T IOrderedCollection<T>.this[int index] => this[index];

			bool IList.IsFixedSize => false;

			bool IList.IsReadOnly => false;

			object IList.this[int index]
			{
				get
				{
					return this[index];
				}
				set
				{
					this[index] = (T)value;
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			internal Builder(ImmutableList<T> list)
			{
				Requires.NotNull(list, "list");
				_root = list._root;
				_immutable = list;
			}

			[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
			public ref T ItemRef(int index)
			{
				return ref Root.ItemRef(index);
			}

			public int IndexOf(T item)
			{
				return Root.IndexOf(item, EqualityComparer<T>.Default);
			}

			public void Insert(int index, T item)
			{
				Root = Root.Insert(index, item);
			}

			public void RemoveAt(int index)
			{
				Root = Root.RemoveAt(index);
			}

			public void Add(T item)
			{
				Root = Root.Add(item);
			}

			public void Clear()
			{
				Root = Node.EmptyNode;
			}

			public bool Contains(T item)
			{
				return IndexOf(item) >= 0;
			}

			public bool Remove(T item)
			{
				int num = IndexOf(item);
				if (num < 0)
				{
					return false;
				}
				Root = Root.RemoveAt(num);
				return true;
			}

			public Enumerator GetEnumerator()
			{
				return Root.GetEnumerator(this);
			}

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

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public void ForEach(Action<T> action)
			{
				Requires.NotNull(action, "action");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					action(current);
				}
			}

			public void CopyTo(T[] array)
			{
				_root.CopyTo(array);
			}

			public void CopyTo(T[] array, int arrayIndex)
			{
				_root.CopyTo(array, arrayIndex);
			}

			public void CopyTo(int index, T[] array, int arrayIndex, int count)
			{
				_root.CopyTo(index, array, arrayIndex, count);
			}

			public ImmutableList<T> GetRange(int index, int count)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				return ImmutableList<T>.WrapNode(Node.NodeTreeFromList(this, index, count));
			}

			public ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter)
			{
				Requires.NotNull(converter, "converter");
				return ImmutableList<TOutput>.WrapNode(_root.ConvertAll(converter));
			}

			public bool Exists(Predicate<T> match)
			{
				return _root.Exists(match);
			}

			public T Find(Predicate<T> match)
			{
				return _root.Find(match);
			}

			public ImmutableList<T> FindAll(Predicate<T> match)
			{
				return _root.FindAll(match);
			}

			public int FindIndex(Predicate<T> match)
			{
				return _root.FindIndex(match);
			}

			public int FindIndex(int startIndex, Predicate<T> match)
			{
				return _root.FindIndex(startIndex, match);
			}

			public int FindIndex(int startIndex, int count, Predicate<T> match)
			{
				return _root.FindIndex(startIndex, count, match);
			}

			public T FindLast(Predicate<T> match)
			{
				return _root.FindLast(match);
			}

			public int FindLastIndex(Predicate<T> match)
			{
				return _root.FindLastIndex(match);
			}

			public int FindLastIndex(int startIndex, Predicate<T> match)
			{
				return _root.FindLastIndex(startIndex, match);
			}

			public int FindLastIndex(int startIndex, int count, Predicate<T> match)
			{
				return _root.FindLastIndex(startIndex, count, match);
			}

			public int IndexOf(T item, int index)
			{
				return _root.IndexOf(item, index, Count - index, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int index, int count)
			{
				return _root.IndexOf(item, index, count, EqualityComparer<T>.Default);
			}

			public int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer)
			{
				return _root.IndexOf(item, index, count, equalityComparer);
			}

			public int LastIndexOf(T item)
			{
				if (Count == 0)
				{
					return -1;
				}
				return _root.LastIndexOf(item, Count - 1, Count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex)
			{
				if (Count == 0 && startIndex == 0)
				{
					return -1;
				}
				return _root.LastIndexOf(item, startIndex, startIndex + 1, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count)
			{
				return _root.LastIndexOf(item, startIndex, count, EqualityComparer<T>.Default);
			}

			public int LastIndexOf(T item, int startIndex, int count, IEqualityComparer<T> equalityComparer)
			{
				return _root.LastIndexOf(item, startIndex, count, equalityComparer);
			}

			public bool TrueForAll(Predicate<T> match)
			{
				return _root.TrueForAll(match);
			}

			public void AddRange(IEnumerable<T> items)
			{
				Requires.NotNull(items, "items");
				Root = Root.AddRange(items);
			}

			public void InsertRange(int index, IEnumerable<T> items)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				Requires.NotNull(items, "items");
				Root = Root.InsertRange(index, items);
			}

			public int RemoveAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				int count = Count;
				Root = Root.RemoveAll(match);
				return count - Count;
			}

			public void Reverse()
			{
				Reverse(0, Count);
			}

			public void Reverse(int index, int count)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				Root = Root.Reverse(index, count);
			}

			public void Sort()
			{
				Root = Root.Sort();
			}

			public void Sort(Comparison<T> comparison)
			{
				Requires.NotNull(comparison, "comparison");
				Root = Root.Sort(comparison);
			}

			public void Sort(IComparer<T> comparer)
			{
				Root = Root.Sort(comparer);
			}

			public void Sort(int index, int count, IComparer<T> comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				Root = Root.Sort(index, count, comparer);
			}

			public int BinarySearch(T item)
			{
				return BinarySearch(item, null);
			}

			public int BinarySearch(T item, IComparer<T> comparer)
			{
				return BinarySearch(0, Count, item, comparer);
			}

			public int BinarySearch(int index, int count, T item, IComparer<T> comparer)
			{
				return Root.BinarySearch(index, count, item, comparer);
			}

			public ImmutableList<T> ToImmutable()
			{
				if (_immutable == null)
				{
					_immutable = ImmutableList<T>.WrapNode(Root);
				}
				return _immutable;
			}

			int IList.Add(object value)
			{
				Add((T)value);
				return Count - 1;
			}

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

			bool IList.Contains(object value)
			{
				if (ImmutableList<T>.IsCompatibleObject(value))
				{
					return Contains((T)value);
				}
				return false;
			}

			int IList.IndexOf(object value)
			{
				if (ImmutableList<T>.IsCompatibleObject(value))
				{
					return IndexOf((T)value);
				}
				return -1;
			}

			void IList.Insert(int index, object value)
			{
				Insert(index, (T)value);
			}

			void IList.Remove(object value)
			{
				if (ImmutableList<T>.IsCompatibleObject(value))
				{
					Remove((T)value);
				}
			}

			void ICollection.CopyTo(Array array, int arrayIndex)
			{
				Root.CopyTo(array, arrayIndex);
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator, ISecurePooledObjectUser, IStrongEnumerator<T>
		{
			private static readonly SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator> s_EnumeratingStacks = new SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>();

			private readonly Builder _builder;

			private readonly int _poolUserId;

			private readonly int _startIndex;

			private readonly int _count;

			private int _remainingCount;

			private bool _reversed;

			private Node _root;

			private SecurePooledObject<Stack<RefAsValueType<Node>>> _stack;

			private Node _current;

			private int _enumeratingBuilderVersion;

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(Node root, Builder builder = null, int startIndex = -1, int count = -1, bool reversed = false)
			{
				Requires.NotNull(root, "root");
				Requires.Range(startIndex >= -1, "startIndex");
				Requires.Range(count >= -1, "count");
				Requires.Argument(reversed || count == -1 || ((startIndex != -1) ? startIndex : 0) + count <= root.Count);
				Requires.Argument(!reversed || count == -1 || ((startIndex == -1) ? (root.Count - 1) : startIndex) - count + 1 >= 0);
				_root = root;
				_builder = builder;
				_current = null;
				_startIndex = ((startIndex >= 0) ? startIndex : (reversed ? (root.Count - 1) : 0));
				_count = ((count == -1) ? root.Count : count);
				_remainingCount = _count;
				_reversed = reversed;
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (_count > 0)
				{
					if (!s_EnumeratingStacks.TryTake(this, out _stack))
					{
						_stack = s_EnumeratingStacks.PrepNew(this, new Stack<RefAsValueType<Node>>(root.Height));
					}
					ResetStack();
				}
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					s_EnumeratingStacks.TryAdd(this, _stack);
				}
				_stack = null;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				ThrowIfChanged();
				if (_stack != null)
				{
					Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
					if (_remainingCount > 0 && stack.Count > 0)
					{
						PushNext(NextBranch(_current = stack.Pop().Value));
						_remainingCount--;
						return true;
					}
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_remainingCount = _count;
				if (_stack != null)
				{
					ResetStack();
				}
			}

			private void ResetStack()
			{
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				stack.ClearFastWhenEmpty();
				Node node = _root;
				int num = (_reversed ? (_root.Count - _startIndex - 1) : _startIndex);
				while (!node.IsEmpty && num != PreviousBranch(node).Count)
				{
					if (num < PreviousBranch(node).Count)
					{
						stack.Push(new RefAsValueType<Node>(node));
						node = PreviousBranch(node);
					}
					else
					{
						num -= PreviousBranch(node).Count + 1;
						node = NextBranch(node);
					}
				}
				if (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<Node>(node));
				}
			}

			private Node NextBranch(Node node)
			{
				if (!_reversed)
				{
					return node.Right;
				}
				return node.Left;
			}

			private Node PreviousBranch(Node node)
			{
				if (!_reversed)
				{
					return node.Left;
				}
				return node.Right;
			}

			private void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}

			private void PushNext(Node node)
			{
				Requires.NotNull(node, "node");
				if (!node.IsEmpty)
				{
					Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
					while (!node.IsEmpty)
					{
						stack.Push(new RefAsValueType<Node>(node));
						node = PreviousBranch(node);
					}
				}
			}
		}

		[DebuggerDisplay("{_key}")]
		internal sealed class Node : IBinaryTree<T>, IBinaryTree, IEnumerable<T>, IEnumerable
		{
			internal static readonly Node EmptyNode = new Node();

			private T _key;

			private bool _frozen;

			private byte _height;

			private int _count;

			private Node _left;

			private Node _right;

			public bool IsEmpty => _left == null;

			public int Height => _height;

			public Node Left => _left;

			IBinaryTree IBinaryTree.Left => _left;

			public Node Right => _right;

			IBinaryTree IBinaryTree.Right => _right;

			IBinaryTree<T> IBinaryTree<T>.Left => _left;

			IBinaryTree<T> IBinaryTree<T>.Right => _right;

			public T Value => _key;

			public int Count => _count;

			internal T Key => _key;

			internal T this[int index]
			{
				get
				{
					Requires.Range(index >= 0 && index < Count, "index");
					if (index < _left._count)
					{
						return _left[index];
					}
					if (index > _left._count)
					{
						return _right[index - _left._count - 1];
					}
					return _key;
				}
			}

			private int BalanceFactor => _right._height - _left._height;

			private bool IsRightHeavy => BalanceFactor >= 2;

			private bool IsLeftHeavy => BalanceFactor <= -2;

			private bool IsBalanced => (uint)(BalanceFactor + 1) <= 2u;

			private Node()
			{
				_frozen = true;
			}

			private Node(T key, Node left, Node right, bool frozen = false)
			{
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				_key = key;
				_left = left;
				_right = right;
				_height = ParentHeight(left, right);
				_count = ParentCount(left, right);
				_frozen = frozen;
			}

			[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
			internal ref T ItemRef(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				if (index < _left._count)
				{
					return ref _left.ItemRef(index);
				}
				if (index > _left._count)
				{
					return ref _right.ItemRef(index - _left._count - 1);
				}
				return ref _key;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			[ExcludeFromCodeCoverage]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			[ExcludeFromCodeCoverage]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			internal Enumerator GetEnumerator(Builder builder)
			{
				return new Enumerator(this, builder);
			}

			internal static Node NodeTreeFromList(IOrderedCollection<T> items, int start, int length)
			{
				Requires.NotNull(items, "items");
				Requires.Range(start >= 0, "start");
				Requires.Range(length >= 0, "length");
				if (length == 0)
				{
					return EmptyNode;
				}
				int num = (length - 1) / 2;
				int num2 = length - 1 - num;
				Node left = NodeTreeFromList(items, start, num2);
				Node right = NodeTreeFromList(items, start + num2 + 1, num);
				return new Node(items[start + num2], left, right, frozen: true);
			}

			internal Node Add(T key)
			{
				if (IsEmpty)
				{
					return CreateLeaf(key);
				}
				Node right = _right.Add(key);
				Node node = MutateRight(right);
				if (!node.IsBalanced)
				{
					return node.BalanceRight();
				}
				return node;
			}

			internal Node Insert(int index, T key)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				if (IsEmpty)
				{
					return CreateLeaf(key);
				}
				if (index <= _left._count)
				{
					Node left = _left.Insert(index, key);
					Node node = MutateLeft(left);
					if (!node.IsBalanced)
					{
						return node.BalanceLeft();
					}
					return node;
				}
				Node right = _right.Insert(index - _left._count - 1, key);
				Node node2 = MutateRight(right);
				if (!node2.IsBalanced)
				{
					return node2.BalanceRight();
				}
				return node2;
			}

			internal Node AddRange(IEnumerable<T> keys)
			{
				Requires.NotNull(keys, "keys");
				if (IsEmpty)
				{
					return CreateRange(keys);
				}
				Node right = _right.AddRange(keys);
				Node node = MutateRight(right);
				return node.BalanceMany();
			}

			internal Node InsertRange(int index, IEnumerable<T> keys)
			{
				Requires.Range(index >= 0 && index <= Count, "index");
				Requires.NotNull(keys, "keys");
				if (IsEmpty)
				{
					return CreateRange(keys);
				}
				Node node;
				if (index <= _left._count)
				{
					Node left = _left.InsertRange(index, keys);
					node = MutateLeft(left);
				}
				else
				{
					Node right = _right.InsertRange(index - _left._count - 1, keys);
					node = MutateRight(right);
				}
				return node.BalanceMany();
			}

			internal Node RemoveAt(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				Node node = this;
				if (index == _left._count)
				{
					if (_right.IsEmpty && _left.IsEmpty)
					{
						node = EmptyNode;
					}
					else if (_right.IsEmpty && !_left.IsEmpty)
					{
						node = _left;
					}
					else if (!_right.IsEmpty && _left.IsEmpty)
					{
						node = _right;
					}
					else
					{
						Node node2 = _right;
						while (!node2._left.IsEmpty)
						{
							node2 = node2._left;
						}
						Node right = _right.RemoveAt(0);
						node = node2.MutateBoth(_left, right);
					}
				}
				else if (index < _left._count)
				{
					Node left = _left.RemoveAt(index);
					node = MutateLeft(left);
				}
				else
				{
					Node right2 = _right.RemoveAt(index - _left._count - 1);
					node = MutateRight(right2);
				}
				if (!node.IsEmpty && !node.IsBalanced)
				{
					return node.Balance();
				}
				return node;
			}

			internal Node RemoveAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Node node = this;
				Enumerator enumerator = new Enumerator(node);
				try
				{
					int num = 0;
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							node = node.RemoveAt(num);
							enumerator.Dispose();
							enumerator = new Enumerator(node, null, num);
						}
						else
						{
							num++;
						}
					}
					return node;
				}
				finally
				{
					enumerator.Dispose();
				}
			}

			internal Node ReplaceAt(int index, T value)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				Node node = this;
				if (index == _left._count)
				{
					return MutateKey(value);
				}
				if (index < _left._count)
				{
					Node left = _left.ReplaceAt(index, value);
					return MutateLeft(left);
				}
				Node right = _right.ReplaceAt(index - _left._count - 1, value);
				return MutateRight(right);
			}

			internal Node Reverse()
			{
				return Reverse(0, Count);
			}

			internal Node Reverse(int index, int count)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "index");
				Node node = this;
				int num = index;
				int num2 = index + count - 1;
				while (num < num2)
				{
					T value = node.ItemRef(num);
					T value2 = node.ItemRef(num2);
					node = node.ReplaceAt(num2, value).ReplaceAt(num, value2);
					num++;
					num2--;
				}
				return node;
			}

			internal Node Sort()
			{
				return Sort(Comparer<T>.Default);
			}

			internal Node Sort(Comparison<T> comparison)
			{
				Requires.NotNull(comparison, "comparison");
				T[] array = new T[Count];
				CopyTo(array);
				Array.Sort(array, comparison);
				return NodeTreeFromList(array.AsOrderedCollection(), 0, Count);
			}

			internal Node Sort(IComparer<T> comparer)
			{
				return Sort(0, Count, comparer);
			}

			internal Node Sort(int index, int count, IComparer<T> comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Argument(index + count <= Count);
				T[] array = new T[Count];
				CopyTo(array);
				Array.Sort(array, index, count, comparer);
				return NodeTreeFromList(array.AsOrderedCollection(), 0, Count);
			}

			internal int BinarySearch(int index, int count, T item, IComparer<T> comparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				comparer = comparer ?? Comparer<T>.Default;
				if (IsEmpty || count <= 0)
				{
					return ~index;
				}
				int count2 = _left.Count;
				if (index + count <= count2)
				{
					return _left.BinarySearch(index, count, item, comparer);
				}
				if (index > count2)
				{
					int num = _right.BinarySearch(index - count2 - 1, count, item, comparer);
					int num2 = count2 + 1;
					if (num >= 0)
					{
						return num + num2;
					}
					return num - num2;
				}
				int num3 = comparer.Compare(item, _key);
				if (num3 == 0)
				{
					return count2;
				}
				if (num3 > 0)
				{
					int num4 = count - (count2 - index) - 1;
					int num5 = ((num4 < 0) ? (-1) : _right.BinarySearch(0, num4, item, comparer));
					int num6 = count2 + 1;
					if (num5 >= 0)
					{
						return num5 + num6;
					}
					return num5 - num6;
				}
				if (index == count2)
				{
					return ~index;
				}
				return _left.BinarySearch(index, count, item, comparer);
			}

			internal int IndexOf(T item, IEqualityComparer<T> equalityComparer)
			{
				return IndexOf(item, 0, Count, equalityComparer);
			}

			internal int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(count <= Count, "count");
				Requires.Range(index + count <= Count, "count");
				equalityComparer = equalityComparer ?? EqualityComparer<T>.Default;
				using (Enumerator enumerator = new Enumerator(this, null, index, count))
				{
					while (enumerator.MoveNext())
					{
						if (equalityComparer.Equals(item, enumerator.Current))
						{
							return index;
						}
						index++;
					}
				}
				return -1;
			}

			internal int LastIndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer)
			{
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0 && count <= Count, "count");
				Requires.Argument(index - count + 1 >= 0);
				equalityComparer = equalityComparer ?? EqualityComparer<T>.Default;
				using (Enumerator enumerator = new Enumerator(this, null, index, count, reversed: true))
				{
					while (enumerator.MoveNext())
					{
						if (equalityComparer.Equals(item, enumerator.Current))
						{
							return index;
						}
						index--;
					}
				}
				return -1;
			}

			internal void CopyTo(T[] array)
			{
				Requires.NotNull(array, "array");
				Requires.Range(array.Length >= Count, "array");
				int num = 0;
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[num++] = current;
				}
			}

			internal void CopyTo(T[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			internal void CopyTo(int index, T[] array, int arrayIndex, int count)
			{
				Requires.NotNull(array, "array");
				Requires.Range(index >= 0, "index");
				Requires.Range(count >= 0, "count");
				Requires.Range(index + count <= Count, "count");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(arrayIndex + count <= array.Length, "arrayIndex");
				using Enumerator enumerator = new Enumerator(this, null, index, count);
				while (enumerator.MoveNext())
				{
					array[arrayIndex++] = enumerator.Current;
				}
			}

			internal void CopyTo(Array array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array.SetValue(current, arrayIndex++);
				}
			}

			internal ImmutableList<TOutput>.Node ConvertAll<TOutput>(Func<T, TOutput> converter)
			{
				ImmutableList<TOutput>.Node emptyNode = ImmutableList<TOutput>.Node.EmptyNode;
				if (IsEmpty)
				{
					return emptyNode;
				}
				return emptyNode.AddRange(this.Select(converter));
			}

			internal bool TrueForAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (!match(current))
						{
							return false;
						}
					}
				}
				return true;
			}

			internal bool Exists(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (match(current))
						{
							return true;
						}
					}
				}
				return false;
			}

			internal T Find(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (match(current))
						{
							return current;
						}
					}
				}
				return default(T);
			}

			internal ImmutableList<T> FindAll(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				if (IsEmpty)
				{
					return ImmutableList<T>.Empty;
				}
				List<T> list = null;
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						T current = enumerator.Current;
						if (match(current))
						{
							if (list == null)
							{
								list = new List<T>();
							}
							list.Add(current);
						}
					}
				}
				if (list == null)
				{
					return ImmutableList<T>.Empty;
				}
				return ImmutableList.CreateRange(list);
			}

			internal int FindIndex(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				return FindIndex(0, _count, match);
			}

			internal int FindIndex(int startIndex, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0 && startIndex <= Count, "startIndex");
				return FindIndex(startIndex, Count - startIndex, match);
			}

			internal int FindIndex(int startIndex, int count, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0, "startIndex");
				Requires.Range(count >= 0, "count");
				Requires.Range(startIndex + count <= Count, "count");
				using (Enumerator enumerator = new Enumerator(this, null, startIndex, count))
				{
					int num = startIndex;
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							return num;
						}
						num++;
					}
				}
				return -1;
			}

			internal T FindLast(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				using (Enumerator enumerator = new Enumerator(this, null, -1, -1, reversed: true))
				{
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							return enumerator.Current;
						}
					}
				}
				return default(T);
			}

			internal int FindLastIndex(Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				if (!IsEmpty)
				{
					return FindLastIndex(Count - 1, Count, match);
				}
				return -1;
			}

			internal int FindLastIndex(int startIndex, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0, "startIndex");
				Requires.Range(startIndex == 0 || startIndex < Count, "startIndex");
				if (!IsEmpty)
				{
					return FindLastIndex(startIndex, startIndex + 1, match);
				}
				return -1;
			}

			internal int FindLastIndex(int startIndex, int count, Predicate<T> match)
			{
				Requires.NotNull(match, "match");
				Requires.Range(startIndex >= 0, "startIndex");
				Requires.Range(count <= Count, "count");
				Requires.Range(startIndex - count + 1 >= 0, "startIndex");
				using (Enumerator enumerator = new Enumerator(this, null, startIndex, count, reversed: true))
				{
					int num = startIndex;
					while (enumerator.MoveNext())
					{
						if (match(enumerator.Current))
						{
							return num;
						}
						num--;
					}
				}
				return -1;
			}

			internal void Freeze()
			{
				if (!_frozen)
				{
					_left.Freeze();
					_right.Freeze();
					_frozen = true;
				}
			}

			private Node RotateLeft()
			{
				return _right.MutateLeft(MutateRight(_right._left));
			}

			private Node RotateRight()
			{
				return _left.MutateRight(MutateLeft(_left._right));
			}

			private Node DoubleLeft()
			{
				Node right = _right;
				Node left = right._left;
				return left.MutateBoth(MutateRight(left._left), right.MutateLeft(left._right));
			}

			private Node DoubleRight()
			{
				Node left = _left;
				Node right = left._right;
				return right.MutateBoth(left.MutateRight(right._left), MutateLeft(right._right));
			}

			private Node Balance()
			{
				if (!IsLeftHeavy)
				{
					return BalanceRight();
				}
				return BalanceLeft();
			}

			private Node BalanceLeft()
			{
				if (_left.BalanceFactor <= 0)
				{
					return RotateRight();
				}
				return DoubleRight();
			}

			private Node BalanceRight()
			{
				if (_right.BalanceFactor >= 0)
				{
					return RotateLeft();
				}
				return DoubleLeft();
			}

			private Node BalanceMany()
			{
				Node node = this;
				while (!node.IsBalanced)
				{
					if (node.IsRightHeavy)
					{
						node = node.BalanceRight();
						node.MutateLeft(node._left.BalanceMany());
					}
					else
					{
						node = node.BalanceLeft();
						node.MutateRight(node._right.BalanceMany());
					}
				}
				return node;
			}

			private Node MutateBoth(Node left, Node right)
			{
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				if (_frozen)
				{
					return new Node(_key, left, right);
				}
				_left = left;
				_right = right;
				_height = ParentHeight(left, right);
				_count = ParentCount(left, right);
				return this;
			}

			private Node MutateLeft(Node left)
			{
				Requires.NotNull(left, "left");
				if (_frozen)
				{
					return new Node(_key, left, _right);
				}
				_left = left;
				_height = ParentHeight(left, _right);
				_count = ParentCount(left, _right);
				return this;
			}

			private Node MutateRight(Node right)
			{
				Requires.NotNull(right, "right");
				if (_frozen)
				{
					return new Node(_key, _left, right);
				}
				_right = right;
				_height = ParentHeight(_left, right);
				_count = ParentCount(_left, right);
				return this;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static byte ParentHeight(Node left, Node right)
			{
				return checked((byte)(1 + Math.Max(left._height, right._height)));
			}

			private static int ParentCount(Node left, Node right)
			{
				return 1 + left._count + right._count;
			}

			private Node MutateKey(T key)
			{
				if (_frozen)
				{
					return new Node(key, _left, _right);
				}
				_key = key;
				return this;
			}

			private static Node CreateRange(IEnumerable<T> keys)
			{
				if (ImmutableList<T>.TryCastToImmutableList(keys, out ImmutableList<T> other))
				{
					return other._root;
				}
				IOrderedCollection<T> orderedCollection = keys.AsOrderedCollection();
				return NodeTreeFromList(orderedCollection, 0, orderedCollection.Count);
			}

			private static Node CreateLeaf(T key)
			{
				return new Node(key, EmptyNode, EmptyNode);
			}
		}

		public static readonly ImmutableList<T> Empty = new ImmutableList<T>();

		private readonly Node _root;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		public bool IsEmpty => _root.IsEmpty;

		public int Count => _root.Count;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		public T this[int index] => _root.ItemRef(index);

		T IOrderedCollection<T>.this[int index] => this[index];

		T IList<T>.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool ICollection<T>.IsReadOnly => true;

		bool IList.IsFixedSize => true;

		bool IList.IsReadOnly => true;

		object IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		internal Node Root => _root;

		internal ImmutableList()
		{
			_root = Node.EmptyNode;
		}

		private ImmutableList(Node root)
		{
			Requires.NotNull(root, "root");
			root.Freeze();
			_root = root;
		}

		public ImmutableList<T> Clear()
		{
			return Empty;
		}

		public int BinarySearch(T item)
		{
			return BinarySearch(item, null);
		}

		public int BinarySearch(T item, IComparer<T> comparer)
		{
			return BinarySearch(0, Count, item, comparer);
		}

		public int BinarySearch(int index, int count, T item, IComparer<T> comparer)
		{
			return _root.BinarySearch(index, count, item, comparer);
		}

		IImmutableList<T> IImmutableList<T>.Clear()
		{
			return Clear();
		}

		[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		public ref T ItemRef(int index)
		{
			return ref _root.ItemRef(index);
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableList<T> Add(T value)
		{
			Node root = _root.Add(value);
			return Wrap(root);
		}

		public ImmutableList<T> AddRange(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty)
			{
				return CreateRange(items);
			}
			Node root = _root.AddRange(items);
			return Wrap(root);
		}

		public ImmutableList<T> Insert(int index, T item)
		{
			Requires.Range(index >= 0 && index <= Count, "index");
			return Wrap(_root.Insert(index, item));
		}

		public ImmutableList<T> InsertRange(int index, IEnumerable<T> items)
		{
			Requires.Range(index >= 0 && index <= Count, "index");
			Requires.NotNull(items, "items");
			Node root = _root.InsertRange(index, items);
			return Wrap(root);
		}

		public ImmutableList<T> Remove(T value)
		{
			return Remove(value, EqualityComparer<T>.Default);
		}

		public ImmutableList<T> Remove(T value, IEqualityComparer<T> equalityComparer)
		{
			int num = this.IndexOf(value, equalityComparer);
			if (num >= 0)
			{
				return RemoveAt(num);
			}
			return this;
		}

		public ImmutableList<T> RemoveRange(int index, int count)
		{
			Requires.Range(index >= 0 && index <= Count, "index");
			Requires.Range(count >= 0 && index + count <= Count, "count");
			Node node = _root;
			int num = count;
			while (num-- > 0)
			{
				node = node.RemoveAt(index);
			}
			return Wrap(node);
		}

		public ImmutableList<T> RemoveRange(IEnumerable<T> items)
		{
			return RemoveRange(items, EqualityComparer<T>.Default);
		}

		public ImmutableList<T> RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty)
			{
				return this;
			}
			Node node = _root;
			foreach (T item in items.GetEnumerableDisposable<T, Enumerator>())
			{
				int num = node.IndexOf(item, equalityComparer);
				if (num >= 0)
				{
					node = node.RemoveAt(num);
				}
			}
			return Wrap(node);
		}

		public ImmutableList<T> RemoveAt(int index)
		{
			Requires.Range(index >= 0 && index < Count, "index");
			Node root = _root.RemoveAt(index);
			return Wrap(root);
		}

		public ImmutableList<T> RemoveAll(Predicate<T> match)
		{
			Requires.NotNull(match, "match");
			return Wrap(_root.RemoveAll(match));
		}

		public ImmutableList<T> SetItem(int index, T value)
		{
			return Wrap(_root.ReplaceAt(index, value));
		}

		public ImmutableList<T> Replace(T oldValue, T newValue)
		{
			return Replace(oldValue, newValue, EqualityComparer<T>.Default);
		}

		public ImmutableList<T> Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer)
		{
			int num = this.IndexOf(oldValue, equalityComparer);
			if (num < 0)
			{
				throw new ArgumentException(System.SR.CannotFindOldValue, "oldValue");
			}
			return SetItem(num, newValue);
		}

		public ImmutableList<T> Reverse()
		{
			return Wrap(_root.Reverse());
		}

		public ImmutableList<T> Reverse(int index, int count)
		{
			return Wrap(_root.Reverse(index, count));
		}

		public ImmutableList<T> Sort()
		{
			return Wrap(_root.Sort());
		}

		public ImmutableList<T> Sort(Comparison<T> comparison)
		{
			Requires.NotNull(comparison, "comparison");
			return Wrap(_root.Sort(comparison));
		}

		public ImmutableList<T> Sort(IComparer<T> comparer)
		{
			return Wrap(_root.Sort(comparer));
		}

		public ImmutableList<T> Sort(int index, int count, IComparer<T> comparer)
		{
			Requires.Range(index >= 0, "index");
			Requires.Range(count >= 0, "count");
			Requires.Range(index + count <= Count, "count");
			return Wrap(_root.Sort(index, count, comparer));
		}

		public void ForEach(Action<T> action)
		{
			Requires.NotNull(action, "action");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				action(current);
			}
		}

		public void CopyTo(T[] array)
		{
			_root.CopyTo(array);
		}

		public void CopyTo(T[] array, int arrayIndex)
		{
			_root.CopyTo(array, arrayIndex);
		}

		public void CopyTo(int index, T[] array, int arrayIndex, int count)
		{
			_root.CopyTo(index, array, arrayIndex, count);
		}

		public ImmutableList<T> GetRange(int index, int count)
		{
			Requires.Range(index >= 0, "index");
			Requires.Range(count >= 0, "count");
			Requires.Range(index + count <= Count, "count");
			return Wrap(Node.NodeTreeFromList(this, index, count));
		}

		public ImmutableList<TOutput> ConvertAll<TOutput>(Func<T, TOutput> converter)
		{
			Requires.NotNull(converter, "converter");
			return ImmutableList<TOutput>.WrapNode(_root.ConvertAll(converter));
		}

		public bool Exists(Predicate<T> match)
		{
			return _root.Exists(match);
		}

		public T Find(Predicate<T> match)
		{
			return _root.Find(match);
		}

		public ImmutableList<T> FindAll(Predicate<T> match)
		{
			return _root.FindAll(match);
		}

		public int FindIndex(Predicate<T> match)
		{
			return _root.FindIndex(match);
		}

		public int FindIndex(int startIndex, Predicate<T> match)
		{
			return _root.FindIndex(startIndex, match);
		}

		public int FindIndex(int startIndex, int count, Predicate<T> match)
		{
			return _root.FindIndex(startIndex, count, match);
		}

		public T FindLast(Predicate<T> match)
		{
			return _root.FindLast(match);
		}

		public int FindLastIndex(Predicate<T> match)
		{
			return _root.FindLastIndex(match);
		}

		public int FindLastIndex(int startIndex, Predicate<T> match)
		{
			return _root.FindLastIndex(startIndex, match);
		}

		public int FindLastIndex(int startIndex, int count, Predicate<T> match)
		{
			return _root.FindLastIndex(startIndex, count, match);
		}

		public int IndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer)
		{
			return _root.IndexOf(item, index, count, equalityComparer);
		}

		public int LastIndexOf(T item, int index, int count, IEqualityComparer<T> equalityComparer)
		{
			return _root.LastIndexOf(item, index, count, equalityComparer);
		}

		public bool TrueForAll(Predicate<T> match)
		{
			return _root.TrueForAll(match);
		}

		public bool Contains(T value)
		{
			return IndexOf(value) >= 0;
		}

		public int IndexOf(T value)
		{
			return this.IndexOf(value, EqualityComparer<T>.Default);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.Add(T value)
		{
			return Add(value);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.AddRange(IEnumerable<T> items)
		{
			return AddRange(items);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.Insert(int index, T item)
		{
			return Insert(index, item);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.InsertRange(int index, IEnumerable<T> items)
		{
			return InsertRange(index, items);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.Remove(T value, IEqualityComparer<T> equalityComparer)
		{
			return Remove(value, equalityComparer);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveAll(Predicate<T> match)
		{
			return RemoveAll(match);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveRange(IEnumerable<T> items, IEqualityComparer<T> equalityComparer)
		{
			return RemoveRange(items, equalityComparer);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveRange(int index, int count)
		{
			return RemoveRange(index, count);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.RemoveAt(int index)
		{
			return RemoveAt(index);
		}

		[ExcludeFromCodeCoverage]
		IImmutableList<T> IImmutableList<T>.SetItem(int index, T value)
		{
			return SetItem(index, value);
		}

		IImmutableList<T> IImmutableList<T>.Replace(T oldValue, T newValue, IEqualityComparer<T> equalityComparer)
		{
			return Replace(oldValue, newValue, equalityComparer);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void IList<T>.Insert(int index, T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			_root.CopyTo(array, arrayIndex);
		}

		int IList.Add(object value)
		{
			throw new NotSupportedException();
		}

		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void IList.Clear()
		{
			throw new NotSupportedException();
		}

		bool IList.Contains(object value)
		{
			if (IsCompatibleObject(value))
			{
				return Contains((T)value);
			}
			return false;
		}

		int IList.IndexOf(object value)
		{
			if (!IsCompatibleObject(value))
			{
				return -1;
			}
			return IndexOf((T)value);
		}

		void IList.Insert(int index, object value)
		{
			throw new NotSupportedException();
		}

		void IList.Remove(object value)
		{
			throw new NotSupportedException();
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(_root);
		}

		private static ImmutableList<T> WrapNode(Node root)
		{
			if (!root.IsEmpty)
			{
				return new ImmutableList<T>(root);
			}
			return Empty;
		}

		private static bool TryCastToImmutableList(IEnumerable<T> sequence, out ImmutableList<T> other)
		{
			other = sequence as ImmutableList<T>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private static bool IsCompatibleObject(object value)
		{
			if (!(value is T))
			{
				if (value == null)
				{
					return default(T) == null;
				}
				return false;
			}
			return true;
		}

		private ImmutableList<T> Wrap(Node root)
		{
			if (root != _root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableList<T>(root);
				}
				return Clear();
			}
			return this;
		}

		private static ImmutableList<T> CreateRange(IEnumerable<T> items)
		{
			if (TryCastToImmutableList(items, out var other))
			{
				return other;
			}
			IOrderedCollection<T> orderedCollection = items.AsOrderedCollection();
			if (orderedCollection.Count == 0)
			{
				return Empty;
			}
			Node root = Node.NodeTreeFromList(orderedCollection, 0, orderedCollection.Count);
			return new ImmutableList<T>(root);
		}
	}
	internal class ImmutableListBuilderDebuggerProxy<T>
	{
		private readonly ImmutableList<T>.Builder _list;

		private T[] _cachedContents;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Contents
		{
			get
			{
				if (_cachedContents == null)
				{
					_cachedContents = _list.ToArray(_list.Count);
				}
				return _cachedContents;
			}
		}

		public ImmutableListBuilderDebuggerProxy(ImmutableList<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			_list = builder;
		}
	}
	internal static class ImmutableQueue
	{
		public static ImmutableQueue<T> Create<T>()
		{
			return ImmutableQueue<T>.Empty;
		}

		public static ImmutableQueue<T> Create<T>(T item)
		{
			return ImmutableQueue<T>.Empty.Enqueue(item);
		}

		public static ImmutableQueue<T> CreateRange<T>(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			if (items is T[] items2)
			{
				return Create(items2);
			}
			using IEnumerator<T> enumerator = items.GetEnumerator();
			if (!enumerator.MoveNext())
			{
				return ImmutableQueue<T>.Empty;
			}
			ImmutableStack<T> forwards = ImmutableStack.Create(enumerator.Current);
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			while (enumerator.MoveNext())
			{
				immutableStack = immutableStack.Push(enumerator.Current);
			}
			return new ImmutableQueue<T>(forwards, immutableStack);
		}

		public static ImmutableQueue<T> Create<T>(params T[] items)
		{
			Requires.NotNull(items, "items");
			if (items.Length == 0)
			{
				return ImmutableQueue<T>.Empty;
			}
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			for (int num = items.Length - 1; num >= 0; num--)
			{
				immutableStack = immutableStack.Push(items[num]);
			}
			return new ImmutableQueue<T>(immutableStack, ImmutableStack<T>.Empty);
		}

		public static IImmutableQueue<T> Dequeue<T>(this IImmutableQueue<T> queue, out T value)
		{
			Requires.NotNull(queue, "queue");
			value = queue.Peek();
			return queue.Dequeue();
		}
	}
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	[DebuggerDisplay("IsEmpty = {IsEmpty}")]
	internal sealed class ImmutableQueue<T> : IImmutableQueue<T>, IEnumerable<T>, IEnumerable
	{
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator
		{
			private readonly ImmutableQueue<T> _originalQueue;

			private ImmutableStack<T> _remainingForwardsStack;

			private ImmutableStack<T> _remainingBackwardsStack;

			public T Current
			{
				get
				{
					if (_remainingForwardsStack == null)
					{
						throw new InvalidOperationException();
					}
					if (!_remainingForwardsStack.IsEmpty)
					{
						return _remainingForwardsStack.Peek();
					}
					if (!_remainingBackwardsStack.IsEmpty)
					{
						return _remainingBackwardsStack.Peek();
					}
					throw new InvalidOperationException();
				}
			}

			internal Enumerator(ImmutableQueue<T> queue)
			{
				_originalQueue = queue;
				_remainingForwardsStack = null;
				_remainingBackwardsStack = null;
			}

			public bool MoveNext()
			{
				if (_remainingForwardsStack == null)
				{
					_remainingForwardsStack = _originalQueue._forwards;
					_remainingBackwardsStack = _originalQueue.BackwardsReversed;
				}
				else if (!_remainingForwardsStack.IsEmpty)
				{
					_remainingForwardsStack = _remainingForwardsStack.Pop();
				}
				else if (!_remainingBackwardsStack.IsEmpty)
				{
					_remainingBackwardsStack = _remainingBackwardsStack.Pop();
				}
				if (_remainingForwardsStack.IsEmpty)
				{
					return !_remainingBackwardsStack.IsEmpty;
				}
				return true;
			}
		}

		private class EnumeratorObject : IEnumerator<T>, IDisposable, IEnumerator
		{
			private readonly ImmutableQueue<T> _originalQueue;

			private ImmutableStack<T> _remainingForwardsStack;

			private ImmutableStack<T> _remainingBackwardsStack;

			private bool _disposed;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_remainingForwardsStack == null)
					{
						throw new InvalidOperationException();
					}
					if (!_remainingForwardsStack.IsEmpty)
					{
						return _remainingForwardsStack.Peek();
					}
					if (!_remainingBackwardsStack.IsEmpty)
					{
						return _remainingBackwardsStack.Peek();
					}
					throw new InvalidOperationException();
				}
			}

			object IEnumerator.Current => Current;

			internal EnumeratorObject(ImmutableQueue<T> queue)
			{
				_originalQueue = queue;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				if (_remainingForwardsStack == null)
				{
					_remainingForwardsStack = _originalQueue._forwards;
					_remainingBackwardsStack = _originalQueue.BackwardsReversed;
				}
				else if (!_remainingForwardsStack.IsEmpty)
				{
					_remainingForwardsStack = _remainingForwardsStack.Pop();
				}
				else if (!_remainingBackwardsStack.IsEmpty)
				{
					_remainingBackwardsStack = _remainingBackwardsStack.Pop();
				}
				if (_remainingForwardsStack.IsEmpty)
				{
					return !_remainingBackwardsStack.IsEmpty;
				}
				return true;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_remainingBackwardsStack = null;
				_remainingForwardsStack = null;
			}

			public void Dispose()
			{
				_disposed = true;
			}

			private void ThrowIfDisposed()
			{
				if (_disposed)
				{
					Requires.FailObjectDisposed(this);
				}
			}
		}

		private static readonly ImmutableQueue<T> s_EmptyField = new ImmutableQueue<T>(ImmutableStack<T>.Empty, ImmutableStack<T>.Empty);

		private readonly ImmutableStack<T> _backwards;

		private readonly ImmutableStack<T> _forwards;

		private ImmutableStack<T> _backwardsReversed;

		public bool IsEmpty => _forwards.IsEmpty;

		public static ImmutableQueue<T> Empty => s_EmptyField;

		private ImmutableStack<T> BackwardsReversed
		{
			get
			{
				if (_backwardsReversed == null)
				{
					_backwardsReversed = _backwards.Reverse();
				}
				return _backwardsReversed;
			}
		}

		internal ImmutableQueue(ImmutableStack<T> forwards, ImmutableStack<T> backwards)
		{
			_forwards = forwards;
			_backwards = backwards;
		}

		public ImmutableQueue<T> Clear()
		{
			return Empty;
		}

		IImmutableQueue<T> IImmutableQueue<T>.Clear()
		{
			return Clear();
		}

		public T Peek()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return _forwards.Peek();
		}

		[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		public ref T PeekRef()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return ref _forwards.PeekRef();
		}

		public ImmutableQueue<T> Enqueue(T value)
		{
			if (IsEmpty)
			{
				return new ImmutableQueue<T>(ImmutableStack.Create(value), ImmutableStack<T>.Empty);
			}
			return new ImmutableQueue<T>(_forwards, _backwards.Push(value));
		}

		IImmutableQueue<T> IImmutableQueue<T>.Enqueue(T value)
		{
			return Enqueue(value);
		}

		public ImmutableQueue<T> Dequeue()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			ImmutableStack<T> immutableStack = _forwards.Pop();
			if (!immutableStack.IsEmpty)
			{
				return new ImmutableQueue<T>(immutableStack, _backwards);
			}
			if (_backwards.IsEmpty)
			{
				return Empty;
			}
			return new ImmutableQueue<T>(BackwardsReversed, ImmutableStack<T>.Empty);
		}

		public ImmutableQueue<T> Dequeue(out T value)
		{
			value = Peek();
			return Dequeue();
		}

		IImmutableQueue<T> IImmutableQueue<T>.Dequeue()
		{
			return Dequeue();
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return new EnumeratorObject(this);
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new EnumeratorObject(this);
		}
	}
	internal static class ImmutableSortedDictionary
	{
		public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>()
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty;
		}

		public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey> keyComparer)
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer);
		}

		public static ImmutableSortedDictionary<TKey, TValue> Create<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer);
		}

		public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.AddRange(items);
		}

		public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey> keyComparer, IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer).AddRange(items);
		}

		public static ImmutableSortedDictionary<TKey, TValue> CreateRange<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(items);
		}

		public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>()
		{
			return Create<TKey, TValue>().ToBuilder();
		}

		public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey> keyComparer)
		{
			return Create<TKey, TValue>(keyComparer).ToBuilder();
		}

		public static ImmutableSortedDictionary<TKey, TValue>.Builder CreateBuilder<TKey, TValue>(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			return Create(keyComparer, valueComparer).ToBuilder();
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			Requires.NotNull(source, "source");
			Requires.NotNull(keySelector, "keySelector");
			Requires.NotNull(elementSelector, "elementSelector");
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source.Select((TSource element) => new KeyValuePair<TKey, TValue>(keySelector(element), elementSelector(element))));
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this ImmutableSortedDictionary<TKey, TValue>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector, IComparer<TKey> keyComparer)
		{
			return source.ToImmutableSortedDictionary(keySelector, elementSelector, keyComparer, null);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TSource, TKey, TValue>(this IEnumerable<TSource> source, Func<TSource, TKey> keySelector, Func<TSource, TValue> elementSelector)
		{
			return source.ToImmutableSortedDictionary(keySelector, elementSelector, null, null);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			Requires.NotNull(source, "source");
			if (source is ImmutableSortedDictionary<TKey, TValue> immutableSortedDictionary)
			{
				return immutableSortedDictionary.WithComparers(keyComparer, valueComparer);
			}
			return ImmutableSortedDictionary<TKey, TValue>.Empty.WithComparers(keyComparer, valueComparer).AddRange(source);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source, IComparer<TKey> keyComparer)
		{
			return source.ToImmutableSortedDictionary(keyComparer, null);
		}

		public static ImmutableSortedDictionary<TKey, TValue> ToImmutableSortedDictionary<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> source)
		{
			return source.ToImmutableSortedDictionary(null, null);
		}
	}
	[DebuggerDisplay("Count = {Count}")]
	[DebuggerTypeProxy(typeof(ImmutableDictionaryDebuggerProxy<, >))]
	internal sealed class ImmutableSortedDictionary<TKey, TValue> : IImmutableDictionary<TKey, TValue>, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, ISortKeyCollection<TKey>, IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection
	{
		[DebuggerDisplay("Count = {Count}")]
		[DebuggerTypeProxy(typeof(ImmutableSortedDictionaryBuilderDebuggerProxy<, >))]
		public sealed class Builder : IDictionary<TKey, TValue>, ICollection<KeyValuePair<TKey, TValue>>, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable, IReadOnlyDictionary<TKey, TValue>, IReadOnlyCollection<KeyValuePair<TKey, TValue>>, IDictionary, ICollection
		{
			private Node _root = Node.EmptyNode;

			private IComparer<TKey> _keyComparer = Comparer<TKey>.Default;

			private IEqualityComparer<TValue> _valueComparer = EqualityComparer<TValue>.Default;

			private int _count;

			private ImmutableSortedDictionary<TKey, TValue> _immutable;

			private int _version;

			private object _syncRoot;

			ICollection<TKey> IDictionary<TKey, TValue>.Keys => Root.Keys.ToArray(Count);

			public IEnumerable<TKey> Keys => Root.Keys;

			ICollection<TValue> IDictionary<TKey, TValue>.Values => Root.Values.ToArray(Count);

			public IEnumerable<TValue> Values => Root.Values;

			public int Count => _count;

			bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => false;

			internal int Version => _version;

			private Node Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			public TValue this[TKey key]
			{
				get
				{
					if (TryGetValue(key, out var value))
					{
						return value;
					}
					throw new KeyNotFoundException(System.SR.Format(System.SR.Arg_KeyNotFoundWithKey, key.ToString()));
				}
				set
				{
					Root = _root.SetItem(key, value, _keyComparer, _valueComparer, out var replacedExistingValue, out var mutated);
					if (mutated && !replacedExistingValue)
					{
						_count++;
					}
				}
			}

			bool IDictionary.IsFixedSize => false;

			bool IDictionary.IsReadOnly => false;

			ICollection IDictionary.Keys => Keys.ToArray(Count);

			ICollection IDictionary.Values => Values.ToArray(Count);

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			public IComparer<TKey> KeyComparer
			{
				get
				{
					return _keyComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value == _keyComparer)
					{
						return;
					}
					Node node = Node.EmptyNode;
					int num = 0;
					using (Enumerator enumerator = GetEnumerator())
					{
						while (enumerator.MoveNext())
						{
							KeyValuePair<TKey, TValue> current = enumerator.Current;
							node = node.Add(current.Key, current.Value, value, _valueComparer, out var mutated);
							if (mutated)
							{
								num++;
							}
						}
					}
					_keyComparer = value;
					Root = node;
					_count = num;
				}
			}

			public IEqualityComparer<TValue> ValueComparer
			{
				get
				{
					return _valueComparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value != _valueComparer)
					{
						_valueComparer = value;
						_immutable = null;
					}
				}
			}

			object IDictionary.this[object key]
			{
				get
				{
					return this[(TKey)key];
				}
				set
				{
					this[(TKey)key] = (TValue)value;
				}
			}

			internal Builder(ImmutableSortedDictionary<TKey, TValue> map)
			{
				Requires.NotNull(map, "map");
				_root = map._root;
				_keyComparer = map.KeyComparer;
				_valueComparer = map.ValueComparer;
				_count = map.Count;
				_immutable = map;
			}

			[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
			public ref TValue ValueRef(TKey key)
			{
				Requires.NotNullAllowStructs(key, "key");
				return ref _root.ValueRef(key, _keyComparer);
			}

			void IDictionary.Add(object key, object value)
			{
				Add((TKey)key, (TValue)value);
			}

			bool IDictionary.Contains(object key)
			{
				return ContainsKey((TKey)key);
			}

			IDictionaryEnumerator IDictionary.GetEnumerator()
			{
				return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
			}

			void IDictionary.Remove(object key)
			{
				Remove((TKey)key);
			}

			void ICollection.CopyTo(Array array, int index)
			{
				Root.CopyTo(array, index, Count);
			}

			public void Add(TKey key, TValue value)
			{
				Root = Root.Add(key, value, _keyComparer, _valueComparer, out var mutated);
				if (mutated)
				{
					_count++;
				}
			}

			public bool ContainsKey(TKey key)
			{
				return Root.ContainsKey(key, _keyComparer);
			}

			public bool Remove(TKey key)
			{
				Root = Root.Remove(key, _keyComparer, out var mutated);
				if (mutated)
				{
					_count--;
				}
				return mutated;
			}

			public bool TryGetValue(TKey key, out TValue value)
			{
				return Root.TryGetValue(key, _keyComparer, out value);
			}

			public bool TryGetKey(TKey equalKey, out TKey actualKey)
			{
				Requires.NotNullAllowStructs(equalKey, "equalKey");
				return Root.TryGetKey(equalKey, _keyComparer, out actualKey);
			}

			public void Add(KeyValuePair<TKey, TValue> item)
			{
				Add(item.Key, item.Value);
			}

			public void Clear()
			{
				Root = Node.EmptyNode;
				_count = 0;
			}

			public bool Contains(KeyValuePair<TKey, TValue> item)
			{
				return Root.Contains(item, _keyComparer, _valueComparer);
			}

			void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
			{
				Root.CopyTo(array, arrayIndex, Count);
			}

			public bool Remove(KeyValuePair<TKey, TValue> item)
			{
				if (Contains(item))
				{
					return Remove(item.Key);
				}
				return false;
			}

			public Enumerator GetEnumerator()
			{
				return Root.GetEnumerator(this);
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public bool ContainsValue(TValue value)
			{
				return _root.ContainsValue(value, _valueComparer);
			}

			public void AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items)
			{
				Requires.NotNull(items, "items");
				foreach (KeyValuePair<TKey, TValue> item in items)
				{
					Add(item);
				}
			}

			public void RemoveRange(IEnumerable<TKey> keys)
			{
				Requires.NotNull(keys, "keys");
				foreach (TKey key in keys)
				{
					Remove(key);
				}
			}

			public TValue GetValueOrDefault(TKey key)
			{
				return GetValueOrDefault(key, default(TValue));
			}

			public TValue GetValueOrDefault(TKey key, TValue defaultValue)
			{
				Requires.NotNullAllowStructs(key, "key");
				if (TryGetValue(key, out var value))
				{
					return value;
				}
				return defaultValue;
			}

			public ImmutableSortedDictionary<TKey, TValue> ToImmutable()
			{
				if (_immutable == null)
				{
					_immutable = ImmutableSortedDictionary<TKey, TValue>.Wrap(Root, _count, _keyComparer, _valueComparer);
				}
				return _immutable;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<KeyValuePair<TKey, TValue>>, IDisposable, IEnumerator, ISecurePooledObjectUser
		{
			private static readonly SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator> s_enumeratingStacks = new SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>();

			private readonly Builder _builder;

			private readonly int _poolUserId;

			private Node _root;

			private SecurePooledObject<Stack<RefAsValueType<Node>>> _stack;

			private Node _current;

			private int _enumeratingBuilderVersion;

			public KeyValuePair<TKey, TValue> Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			object IEnumerator.Current => Current;

			internal Enumerator(Node root, Builder builder = null)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_builder = builder;
				_current = null;
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (!_root.IsEmpty)
				{
					if (!s_enumeratingStacks.TryTake(this, out _stack))
					{
						_stack = s_enumeratingStacks.PrepNew(this, new Stack<RefAsValueType<Node>>(root.Height));
					}
					PushLeft(_root);
				}
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					s_enumeratingStacks.TryAdd(this, _stack);
				}
				_stack = null;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				ThrowIfChanged();
				if (_stack != null)
				{
					Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
					if (stack.Count > 0)
					{
						PushLeft((_current = stack.Pop().Value).Right);
						return true;
					}
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_current = null;
				if (_stack != null)
				{
					Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
					stack.ClearFastWhenEmpty();
					PushLeft(_root);
				}
			}

			internal void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}

			private void PushLeft(Node node)
			{
				Requires.NotNull(node, "node");
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				while (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<Node>(node));
					node = node.Left;
				}
			}
		}

		[DebuggerDisplay("{_key} = {_value}")]
		internal sealed class Node : IBinaryTree<KeyValuePair<TKey, TValue>>, IBinaryTree, IEnumerable<KeyValuePair<TKey, TValue>>, IEnumerable
		{
			internal static readonly Node EmptyNode = new Node();

			private readonly TKey _key;

			private readonly TValue _value;

			private bool _frozen;

			private byte _height;

			private Node _left;

			private Node _right;

			public bool IsEmpty => _left == null;

			IBinaryTree<KeyValuePair<TKey, TValue>> IBinaryTree<KeyValuePair<TKey, TValue>>.Left => _left;

			IBinaryTree<KeyValuePair<TKey, TValue>> IBinaryTree<KeyValuePair<TKey, TValue>>.Right => _right;

			public int Height => _height;

			public Node Left => _left;

			IBinaryTree IBinaryTree.Left => _left;

			public Node Right => _right;

			IBinaryTree IBinaryTree.Right => _right;

			public KeyValuePair<TKey, TValue> Value => new KeyValuePair<TKey, TValue>(_key, _value);

			int IBinaryTree.Count
			{
				get
				{
					throw new NotSupportedException();
				}
			}

			internal IEnumerable<TKey> Keys => this.Select((KeyValuePair<TKey, TValue> p) => p.Key);

			internal IEnumerable<TValue> Values => this.Select((KeyValuePair<TKey, TValue> p) => p.Value);

			private Node()
			{
				_frozen = true;
			}

			private Node(TKey key, TValue value, Node left, Node right, bool frozen = false)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				_key = key;
				_value = value;
				_left = left;
				_right = right;
				_height = checked((byte)(1 + Math.Max(left._height, right._height)));
				_frozen = frozen;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
			{
				return GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			internal Enumerator GetEnumerator(Builder builder)
			{
				return new Enumerator(this, builder);
			}

			internal void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex, int dictionarySize)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + dictionarySize, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			internal void CopyTo(Array array, int arrayIndex, int dictionarySize)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + dictionarySize, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					KeyValuePair<TKey, TValue> current = enumerator.Current;
					array.SetValue(new DictionaryEntry(current.Key, current.Value), arrayIndex++);
				}
			}

			internal static Node NodeTreeFromSortedDictionary(SortedDictionary<TKey, TValue> dictionary)
			{
				Requires.NotNull(dictionary, "dictionary");
				IOrderedCollection<KeyValuePair<TKey, TValue>> orderedCollection = dictionary.AsOrderedCollection();
				return NodeTreeFromList(orderedCollection, 0, orderedCollection.Count);
			}

			internal Node Add(TKey key, TValue value, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, out bool mutated)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				bool replacedExistingValue;
				return SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue: false, out replacedExistingValue, out mutated);
			}

			internal Node SetItem(TKey key, TValue value, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, out bool replacedExistingValue, out bool mutated)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				return SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue: true, out replacedExistingValue, out mutated);
			}

			internal Node Remove(TKey key, IComparer<TKey> keyComparer, out bool mutated)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				return RemoveRecursive(key, keyComparer, out mutated);
			}

			[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
			internal ref TValue ValueRef(TKey key, IComparer<TKey> keyComparer)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Node node = Search(key, keyComparer);
				if (node.IsEmpty)
				{
					throw new KeyNotFoundException(System.SR.Format(System.SR.Arg_KeyNotFoundWithKey, key.ToString()));
				}
				return ref node._value;
			}

			internal bool TryGetValue(TKey key, IComparer<TKey> keyComparer, out TValue value)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				Node node = Search(key, keyComparer);
				if (node.IsEmpty)
				{
					value = default(TValue);
					return false;
				}
				value = node._value;
				return true;
			}

			internal bool TryGetKey(TKey equalKey, IComparer<TKey> keyComparer, out TKey actualKey)
			{
				Requires.NotNullAllowStructs(equalKey, "equalKey");
				Requires.NotNull(keyComparer, "keyComparer");
				Node node = Search(equalKey, keyComparer);
				if (node.IsEmpty)
				{
					actualKey = equalKey;
					return false;
				}
				actualKey = node._key;
				return true;
			}

			internal bool ContainsKey(TKey key, IComparer<TKey> keyComparer)
			{
				Requires.NotNullAllowStructs(key, "key");
				Requires.NotNull(keyComparer, "keyComparer");
				return !Search(key, keyComparer).IsEmpty;
			}

			internal bool ContainsValue(TValue value, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNull(valueComparer, "valueComparer");
				using (Enumerator enumerator = GetEnumerator())
				{
					while (enumerator.MoveNext())
					{
						if (valueComparer.Equals(value, enumerator.Current.Value))
						{
							return true;
						}
					}
				}
				return false;
			}

			internal bool Contains(KeyValuePair<TKey, TValue> pair, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
			{
				Requires.NotNullAllowStructs(pair.Key, "Key");
				Requires.NotNull(keyComparer, "keyComparer");
				Requires.NotNull(valueComparer, "valueComparer");
				Node node = Search(pair.Key, keyComparer);
				if (node.IsEmpty)
				{
					return false;
				}
				return valueComparer.Equals(node._value, pair.Value);
			}

			internal void Freeze()
			{
				if (!_frozen)
				{
					_left.Freeze();
					_right.Freeze();
					_frozen = true;
				}
			}

			private static Node RotateLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				Node right = tree._right;
				return right.Mutate(tree.Mutate(null, right._left));
			}

			private static Node RotateRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				Node left = tree._left;
				return left.Mutate(null, tree.Mutate(left._right));
			}

			private static Node DoubleLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				Node tree2 = tree.Mutate(null, RotateRight(tree._right));
				return RotateLeft(tree2);
			}

			private static Node DoubleRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				Node tree2 = tree.Mutate(RotateLeft(tree._left));
				return RotateRight(tree2);
			}

			private static int Balance(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return tree._right._height - tree._left._height;
			}

			private static bool IsRightHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) >= 2;
			}

			private static bool IsLeftHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) <= -2;
			}

			private static Node MakeBalanced(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (IsRightHeavy(tree))
				{
					if (Balance(tree._right) >= 0)
					{
						return RotateLeft(tree);
					}
					return DoubleLeft(tree);
				}
				if (IsLeftHeavy(tree))
				{
					if (Balance(tree._left) <= 0)
					{
						return RotateRight(tree);
					}
					return DoubleRight(tree);
				}
				return tree;
			}

			private static Node NodeTreeFromList(IOrderedCollection<KeyValuePair<TKey, TValue>> items, int start, int length)
			{
				Requires.NotNull(items, "items");
				Requires.Range(start >= 0, "start");
				Requires.Range(length >= 0, "length");
				if (length == 0)
				{
					return EmptyNode;
				}
				int num = (length - 1) / 2;
				int num2 = length - 1 - num;
				Node left = NodeTreeFromList(items, start, num2);
				Node right = NodeTreeFromList(items, start + num2 + 1, num);
				KeyValuePair<TKey, TValue> keyValuePair = items[start + num2];
				return new Node(keyValuePair.Key, keyValuePair.Value, left, right, frozen: true);
			}

			private Node SetOrAdd(TKey key, TValue value, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue, out bool replacedExistingValue, out bool mutated)
			{
				replacedExistingValue = false;
				if (IsEmpty)
				{
					mutated = true;
					return new Node(key, value, this, this);
				}
				Node node = this;
				int num = keyComparer.Compare(key, _key);
				if (num > 0)
				{
					Node right = _right.SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
					if (mutated)
					{
						node = Mutate(null, right);
					}
				}
				else if (num < 0)
				{
					Node left = _left.SetOrAdd(key, value, keyComparer, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				else
				{
					if (valueComparer.Equals(_value, value))
					{
						mutated = false;
						return this;
					}
					if (!overwriteExistingValue)
					{
						throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
					}
					mutated = true;
					replacedExistingValue = true;
					node = new Node(key, value, _left, _right);
				}
				if (!mutated)
				{
					return node;
				}
				return MakeBalanced(node);
			}

			private Node RemoveRecursive(TKey key, IComparer<TKey> keyComparer, out bool mutated)
			{
				if (IsEmpty)
				{
					mutated = false;
					return this;
				}
				Node node = this;
				int num = keyComparer.Compare(key, _key);
				if (num == 0)
				{
					mutated = true;
					if (_right.IsEmpty && _left.IsEmpty)
					{
						node = EmptyNode;
					}
					else if (_right.IsEmpty && !_left.IsEmpty)
					{
						node = _left;
					}
					else if (!_right.IsEmpty && _left.IsEmpty)
					{
						node = _right;
					}
					else
					{
						Node node2 = _right;
						while (!node2._left.IsEmpty)
						{
							node2 = node2._left;
						}
						bool mutated2;
						Node right = _right.Remove(node2._key, keyComparer, out mutated2);
						node = node2.Mutate(_left, right);
					}
				}
				else if (num < 0)
				{
					Node left = _left.Remove(key, keyComparer, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				else
				{
					Node right2 = _right.Remove(key, keyComparer, out mutated);
					if (mutated)
					{
						node = Mutate(null, right2);
					}
				}
				if (!node.IsEmpty)
				{
					return MakeBalanced(node);
				}
				return node;
			}

			private Node Mutate(Node left = null, Node right = null)
			{
				if (_frozen)
				{
					return new Node(_key, _value, left ?? _left, right ?? _right);
				}
				if (left != null)
				{
					_left = left;
				}
				if (right != null)
				{
					_right = right;
				}
				_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));
				return this;
			}

			private Node Search(TKey key, IComparer<TKey> keyComparer)
			{
				if (IsEmpty)
				{
					return this;
				}
				int num = keyComparer.Compare(key, _key);
				if (num == 0)
				{
					return this;
				}
				if (num > 0)
				{
					return _right.Search(key, keyComparer);
				}
				return _left.Search(key, keyComparer);
			}
		}

		public static readonly ImmutableSortedDictionary<TKey, TValue> Empty = new ImmutableSortedDictionary<TKey, TValue>();

		private readonly Node _root;

		private readonly int _count;

		private readonly IComparer<TKey> _keyComparer;

		private readonly IEqualityComparer<TValue> _valueComparer;

		public IEqualityComparer<TValue> ValueComparer => _valueComparer;

		public bool IsEmpty => _root.IsEmpty;

		public int Count => _count;

		public IEnumerable<TKey> Keys => _root.Keys;

		public IEnumerable<TValue> Values => _root.Values;

		ICollection<TKey> IDictionary<TKey, TValue>.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection<TValue> IDictionary<TKey, TValue>.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;

		public IComparer<TKey> KeyComparer => _keyComparer;

		internal Node Root => _root;

		public TValue this[TKey key]
		{
			get
			{
				Requires.NotNullAllowStructs(key, "key");
				if (TryGetValue(key, out var value))
				{
					return value;
				}
				throw new KeyNotFoundException(System.SR.Format(System.SR.Arg_KeyNotFoundWithKey, key.ToString()));
			}
		}

		TValue IDictionary<TKey, TValue>.this[TKey key]
		{
			get
			{
				return this[key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool IDictionary.IsFixedSize => true;

		bool IDictionary.IsReadOnly => true;

		ICollection IDictionary.Keys => new KeysCollectionAccessor<TKey, TValue>(this);

		ICollection IDictionary.Values => new ValuesCollectionAccessor<TKey, TValue>(this);

		object IDictionary.this[object key]
		{
			get
			{
				return this[(TKey)key];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		internal ImmutableSortedDictionary(IComparer<TKey> keyComparer = null, IEqualityComparer<TValue> valueComparer = null)
		{
			_keyComparer = keyComparer ?? Comparer<TKey>.Default;
			_valueComparer = valueComparer ?? EqualityComparer<TValue>.Default;
			_root = Node.EmptyNode;
		}

		private ImmutableSortedDictionary(Node root, int count, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			Requires.NotNull(root, "root");
			Requires.Range(count >= 0, "count");
			Requires.NotNull(keyComparer, "keyComparer");
			Requires.NotNull(valueComparer, "valueComparer");
			root.Freeze();
			_root = root;
			_count = count;
			_keyComparer = keyComparer;
			_valueComparer = valueComparer;
		}

		public ImmutableSortedDictionary<TKey, TValue> Clear()
		{
			if (!_root.IsEmpty)
			{
				return Empty.WithComparers(_keyComparer, _valueComparer);
			}
			return this;
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Clear()
		{
			return Clear();
		}

		[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		public ref TValue ValueRef(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return ref _root.ValueRef(key, _keyComparer);
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableSortedDictionary<TKey, TValue> Add(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			bool mutated;
			Node root = _root.Add(key, value, _keyComparer, _valueComparer, out mutated);
			return Wrap(root, _count + 1);
		}

		public ImmutableSortedDictionary<TKey, TValue> SetItem(TKey key, TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			bool replacedExistingValue;
			bool mutated;
			Node root = _root.SetItem(key, value, _keyComparer, _valueComparer, out replacedExistingValue, out mutated);
			return Wrap(root, replacedExistingValue ? _count : (_count + 1));
		}

		public ImmutableSortedDictionary<TKey, TValue> SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			Requires.NotNull(items, "items");
			return AddRange(items, overwriteOnCollision: true, avoidToSortedMap: false);
		}

		public ImmutableSortedDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			Requires.NotNull(items, "items");
			return AddRange(items, overwriteOnCollision: false, avoidToSortedMap: false);
		}

		public ImmutableSortedDictionary<TKey, TValue> Remove(TKey value)
		{
			Requires.NotNullAllowStructs(value, "value");
			bool mutated;
			Node root = _root.Remove(value, _keyComparer, out mutated);
			return Wrap(root, _count - 1);
		}

		public ImmutableSortedDictionary<TKey, TValue> RemoveRange(IEnumerable<TKey> keys)
		{
			Requires.NotNull(keys, "keys");
			Node node = _root;
			int num = _count;
			foreach (TKey key in keys)
			{
				bool mutated;
				Node node2 = node.Remove(key, _keyComparer, out mutated);
				if (mutated)
				{
					node = node2;
					num--;
				}
			}
			return Wrap(node, num);
		}

		public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			if (keyComparer == null)
			{
				keyComparer = Comparer<TKey>.Default;
			}
			if (valueComparer == null)
			{
				valueComparer = EqualityComparer<TValue>.Default;
			}
			if (keyComparer == _keyComparer)
			{
				if (valueComparer == _valueComparer)
				{
					return this;
				}
				return new ImmutableSortedDictionary<TKey, TValue>(_root, _count, _keyComparer, valueComparer);
			}
			ImmutableSortedDictionary<TKey, TValue> immutableSortedDictionary = new ImmutableSortedDictionary<TKey, TValue>(Node.EmptyNode, 0, keyComparer, valueComparer);
			return immutableSortedDictionary.AddRange(this, overwriteOnCollision: false, avoidToSortedMap: true);
		}

		public ImmutableSortedDictionary<TKey, TValue> WithComparers(IComparer<TKey> keyComparer)
		{
			return WithComparers(keyComparer, _valueComparer);
		}

		public bool ContainsValue(TValue value)
		{
			return _root.ContainsValue(value, _valueComparer);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			return Add(key, value);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItem(TKey key, TValue value)
		{
			return SetItem(key, value);
		}

		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.SetItems(IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			return SetItems(items);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.AddRange(IEnumerable<KeyValuePair<TKey, TValue>> pairs)
		{
			return AddRange(pairs);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.RemoveRange(IEnumerable<TKey> keys)
		{
			return RemoveRange(keys);
		}

		[ExcludeFromCodeCoverage]
		IImmutableDictionary<TKey, TValue> IImmutableDictionary<TKey, TValue>.Remove(TKey key)
		{
			return Remove(key);
		}

		public bool ContainsKey(TKey key)
		{
			Requires.NotNullAllowStructs(key, "key");
			return _root.ContainsKey(key, _keyComparer);
		}

		public bool Contains(KeyValuePair<TKey, TValue> pair)
		{
			return _root.Contains(pair, _keyComparer, _valueComparer);
		}

		public bool TryGetValue(TKey key, out TValue value)
		{
			Requires.NotNullAllowStructs(key, "key");
			return _root.TryGetValue(key, _keyComparer, out value);
		}

		public bool TryGetKey(TKey equalKey, out TKey actualKey)
		{
			Requires.NotNullAllowStructs(equalKey, "equalKey");
			return _root.TryGetKey(equalKey, _keyComparer, out actualKey);
		}

		void IDictionary<TKey, TValue>.Add(TKey key, TValue value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary<TKey, TValue>.Remove(TKey key)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Add(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<KeyValuePair<TKey, TValue>>.Remove(KeyValuePair<TKey, TValue> item)
		{
			throw new NotSupportedException();
		}

		void ICollection<KeyValuePair<TKey, TValue>>.CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using Enumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				KeyValuePair<TKey, TValue> current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		void IDictionary.Add(object key, object value)
		{
			throw new NotSupportedException();
		}

		bool IDictionary.Contains(object key)
		{
			return ContainsKey((TKey)key);
		}

		IDictionaryEnumerator IDictionary.GetEnumerator()
		{
			return new DictionaryEnumerator<TKey, TValue>(GetEnumerator());
		}

		void IDictionary.Remove(object key)
		{
			throw new NotSupportedException();
		}

		void IDictionary.Clear()
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			_root.CopyTo(array, index, Count);
		}

		[ExcludeFromCodeCoverage]
		IEnumerator<KeyValuePair<TKey, TValue>> IEnumerable<KeyValuePair<TKey, TValue>>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<KeyValuePair<TKey, TValue>>().GetEnumerator();
		}

		[ExcludeFromCodeCoverage]
		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public Enumerator GetEnumerator()
		{
			return _root.GetEnumerator();
		}

		private static ImmutableSortedDictionary<TKey, TValue> Wrap(Node root, int count, IComparer<TKey> keyComparer, IEqualityComparer<TValue> valueComparer)
		{
			if (!root.IsEmpty)
			{
				return new ImmutableSortedDictionary<TKey, TValue>(root, count, keyComparer, valueComparer);
			}
			return Empty.WithComparers(keyComparer, valueComparer);
		}

		private static bool TryCastToImmutableMap(IEnumerable<KeyValuePair<TKey, TValue>> sequence, out ImmutableSortedDictionary<TKey, TValue> other)
		{
			other = sequence as ImmutableSortedDictionary<TKey, TValue>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private ImmutableSortedDictionary<TKey, TValue> AddRange(IEnumerable<KeyValuePair<TKey, TValue>> items, bool overwriteOnCollision, bool avoidToSortedMap)
		{
			Requires.NotNull(items, "items");
			if (IsEmpty && !avoidToSortedMap)
			{
				return FillFromEmpty(items, overwriteOnCollision);
			}
			Node node = _root;
			int num = _count;
			foreach (KeyValuePair<TKey, TValue> item in items)
			{
				bool replacedExistingValue = false;
				bool mutated;
				Node node2 = (overwriteOnCollision ? node.SetItem(item.Key, item.Value, _keyComparer, _valueComparer, out replacedExistingValue, out mutated) : node.Add(item.Key, item.Value, _keyComparer, _valueComparer, out mutated));
				if (mutated)
				{
					node = node2;
					if (!replacedExistingValue)
					{
						num++;
					}
				}
			}
			return Wrap(node, num);
		}

		private ImmutableSortedDictionary<TKey, TValue> Wrap(Node root, int adjustedCountIfDifferentRoot)
		{
			if (_root != root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableSortedDictionary<TKey, TValue>(root, adjustedCountIfDifferentRoot, _keyComparer, _valueComparer);
				}
				return Clear();
			}
			return this;
		}

		private ImmutableSortedDictionary<TKey, TValue> FillFromEmpty(IEnumerable<KeyValuePair<TKey, TValue>> items, bool overwriteOnCollision)
		{
			Requires.NotNull(items, "items");
			if (TryCastToImmutableMap(items, out var other))
			{
				return other.WithComparers(KeyComparer, ValueComparer);
			}
			SortedDictionary<TKey, TValue> sortedDictionary;
			if (items is IDictionary<TKey, TValue> dictionary)
			{
				sortedDictionary = new SortedDictionary<TKey, TValue>(dictionary, KeyComparer);
			}
			else
			{
				sortedDictionary = new SortedDictionary<TKey, TValue>(KeyComparer);
				foreach (KeyValuePair<TKey, TValue> item in items)
				{
					TValue value;
					if (overwriteOnCollision)
					{
						sortedDictionary[item.Key] = item.Value;
					}
					else if (sortedDictionary.TryGetValue(item.Key, out value))
					{
						if (!_valueComparer.Equals(value, item.Value))
						{
							throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, item.Key));
						}
					}
					else
					{
						sortedDictionary.Add(item.Key, item.Value);
					}
				}
			}
			if (sortedDictionary.Count == 0)
			{
				return this;
			}
			Node root = Node.NodeTreeFromSortedDictionary(sortedDictionary);
			return new ImmutableSortedDictionary<TKey, TValue>(root, sortedDictionary.Count, KeyComparer, ValueComparer);
		}
	}
	internal class ImmutableSortedDictionaryBuilderDebuggerProxy<TKey, TValue>
	{
		private readonly ImmutableSortedDictionary<TKey, TValue>.Builder _map;

		private KeyValuePair<TKey, TValue>[] _contents;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public KeyValuePair<TKey, TValue>[] Contents
		{
			get
			{
				if (_contents == null)
				{
					_contents = _map.ToArray(_map.Count);
				}
				return _contents;
			}
		}

		public ImmutableSortedDictionaryBuilderDebuggerProxy(ImmutableSortedDictionary<TKey, TValue>.Builder map)
		{
			Requires.NotNull(map, "map");
			_map = map;
		}
	}
	internal static class ImmutableSortedSet
	{
		public static ImmutableSortedSet<T> Create<T>()
		{
			return ImmutableSortedSet<T>.Empty;
		}

		public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer);
		}

		public static ImmutableSortedSet<T> Create<T>(T item)
		{
			return ImmutableSortedSet<T>.Empty.Add(item);
		}

		public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer, T item)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer).Add(item);
		}

		public static ImmutableSortedSet<T> CreateRange<T>(IEnumerable<T> items)
		{
			return ImmutableSortedSet<T>.Empty.Union(items);
		}

		public static ImmutableSortedSet<T> CreateRange<T>(IComparer<T> comparer, IEnumerable<T> items)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer).Union(items);
		}

		public static ImmutableSortedSet<T> Create<T>(params T[] items)
		{
			return ImmutableSortedSet<T>.Empty.Union(items);
		}

		public static ImmutableSortedSet<T> Create<T>(IComparer<T> comparer, params T[] items)
		{
			return ImmutableSortedSet<T>.Empty.WithComparer(comparer).Union(items);
		}

		public static ImmutableSortedSet<T>.Builder CreateBuilder<T>()
		{
			return Create<T>().ToBuilder();
		}

		public static ImmutableSortedSet<T>.Builder CreateBuilder<T>(IComparer<T> comparer)
		{
			return Create(comparer).ToBuilder();
		}

		public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source, IComparer<TSource> comparer)
		{
			if (source is ImmutableSortedSet<TSource> immutableSortedSet)
			{
				return immutableSortedSet.WithComparer(comparer);
			}
			return ImmutableSortedSet<TSource>.Empty.WithComparer(comparer).Union(source);
		}

		public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this IEnumerable<TSource> source)
		{
			return source.ToImmutableSortedSet(null);
		}

		public static ImmutableSortedSet<TSource> ToImmutableSortedSet<TSource>(this ImmutableSortedSet<TSource>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			return builder.ToImmutable();
		}
	}
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	[DebuggerDisplay("Count = {Count}")]
	internal sealed class ImmutableSortedSet<T> : IImmutableSet<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, ISortKeyCollection<T>, IReadOnlyList<T>, IList<T>, ICollection<T>, ISet<T>, IList, ICollection, IStrongEnumerable<T, ImmutableSortedSet<T>.Enumerator>
	{
		[DebuggerTypeProxy(typeof(ImmutableSortedSetBuilderDebuggerProxy<>))]
		[DebuggerDisplay("Count = {Count}")]
		public sealed class Builder : ISortKeyCollection<T>, IReadOnlyCollection<T>, IEnumerable<T>, IEnumerable, ISet<T>, ICollection<T>, ICollection
		{
			private Node _root = Node.EmptyNode;

			private IComparer<T> _comparer = Comparer<T>.Default;

			private ImmutableSortedSet<T> _immutable;

			private int _version;

			private object _syncRoot;

			public int Count => Root.Count;

			bool ICollection<T>.IsReadOnly => false;

			public T this[int index] => _root.ItemRef(index);

			public T Max => _root.Max;

			public T Min => _root.Min;

			public IComparer<T> KeyComparer
			{
				get
				{
					return _comparer;
				}
				set
				{
					Requires.NotNull(value, "value");
					if (value == _comparer)
					{
						return;
					}
					Node node = Node.EmptyNode;
					using (Enumerator enumerator = GetEnumerator())
					{
						while (enumerator.MoveNext())
						{
							T current = enumerator.Current;
							node = node.Add(current, value, out var _);
						}
					}
					_immutable = null;
					_comparer = value;
					Root = node;
				}
			}

			internal int Version => _version;

			private Node Root
			{
				get
				{
					return _root;
				}
				set
				{
					_version++;
					if (_root != value)
					{
						_root = value;
						_immutable = null;
					}
				}
			}

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			bool ICollection.IsSynchronized => false;

			[DebuggerBrowsable(DebuggerBrowsableState.Never)]
			object ICollection.SyncRoot
			{
				get
				{
					if (_syncRoot == null)
					{
						Interlocked.CompareExchange<object>(ref _syncRoot, new object(), (object)null);
					}
					return _syncRoot;
				}
			}

			internal Builder(ImmutableSortedSet<T> set)
			{
				Requires.NotNull(set, "set");
				_root = set._root;
				_comparer = set.KeyComparer;
				_immutable = set;
			}

			[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
			public ref T ItemRef(int index)
			{
				return ref _root.ItemRef(index);
			}

			public bool Add(T item)
			{
				Root = Root.Add(item, _comparer, out var mutated);
				return mutated;
			}

			public void ExceptWith(IEnumerable<T> other)
			{
				Requires.NotNull(other, "other");
				foreach (T item in other)
				{
					Root = Root.Remove(item, _comparer, out var _);
				}
			}

			public void IntersectWith(IEnumerable<T> other)
			{
				Requires.NotNull(other, "other");
				Node node = Node.EmptyNode;
				foreach (T item in other)
				{
					if (Contains(item))
					{
						node = node.Add(item, _comparer, out var _);
					}
				}
				Root = node;
			}

			public bool IsProperSubsetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsProperSubsetOf(other);
			}

			public bool IsProperSupersetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsProperSupersetOf(other);
			}

			public bool IsSubsetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsSubsetOf(other);
			}

			public bool IsSupersetOf(IEnumerable<T> other)
			{
				return ToImmutable().IsSupersetOf(other);
			}

			public bool Overlaps(IEnumerable<T> other)
			{
				return ToImmutable().Overlaps(other);
			}

			public bool SetEquals(IEnumerable<T> other)
			{
				return ToImmutable().SetEquals(other);
			}

			public void SymmetricExceptWith(IEnumerable<T> other)
			{
				Root = ToImmutable().SymmetricExcept(other)._root;
			}

			public void UnionWith(IEnumerable<T> other)
			{
				Requires.NotNull(other, "other");
				foreach (T item in other)
				{
					Root = Root.Add(item, _comparer, out var _);
				}
			}

			void ICollection<T>.Add(T item)
			{
				Add(item);
			}

			public void Clear()
			{
				Root = Node.EmptyNode;
			}

			public bool Contains(T item)
			{
				return Root.Contains(item, _comparer);
			}

			void ICollection<T>.CopyTo(T[] array, int arrayIndex)
			{
				_root.CopyTo(array, arrayIndex);
			}

			public bool Remove(T item)
			{
				Root = Root.Remove(item, _comparer, out var mutated);
				return mutated;
			}

			public Enumerator GetEnumerator()
			{
				return Root.GetEnumerator(this);
			}

			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return Root.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			public IEnumerable<T> Reverse()
			{
				return new ReverseEnumerable(_root);
			}

			public ImmutableSortedSet<T> ToImmutable()
			{
				if (_immutable == null)
				{
					_immutable = ImmutableSortedSet<T>.Wrap(Root, _comparer);
				}
				return _immutable;
			}

			void ICollection.CopyTo(Array array, int arrayIndex)
			{
				Root.CopyTo(array, arrayIndex);
			}
		}

		private class ReverseEnumerable : IEnumerable<T>, IEnumerable
		{
			private readonly Node _root;

			internal ReverseEnumerable(Node root)
			{
				Requires.NotNull(root, "root");
				_root = root;
			}

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

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator, ISecurePooledObjectUser, IStrongEnumerator<T>
		{
			private static readonly SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator> s_enumeratingStacks = new SecureObjectPool<Stack<RefAsValueType<Node>>, Enumerator>();

			private readonly Builder _builder;

			private readonly int _poolUserId;

			private readonly bool _reverse;

			private Node _root;

			private SecurePooledObject<Stack<RefAsValueType<Node>>> _stack;

			private Node _current;

			private int _enumeratingBuilderVersion;

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			object IEnumerator.Current => Current;

			internal Enumerator(Node root, Builder builder = null, bool reverse = false)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_builder = builder;
				_current = null;
				_reverse = reverse;
				_enumeratingBuilderVersion = builder?.Version ?? (-1);
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (!s_enumeratingStacks.TryTake(this, out _stack))
				{
					_stack = s_enumeratingStacks.PrepNew(this, new Stack<RefAsValueType<Node>>(root.Height));
				}
				PushNext(_root);
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					s_enumeratingStacks.TryAdd(this, _stack);
					_stack = null;
				}
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				ThrowIfChanged();
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				if (stack.Count > 0)
				{
					Node node = (_current = stack.Pop().Value);
					PushNext(_reverse ? node.Left : node.Right);
					return true;
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_enumeratingBuilderVersion = ((_builder != null) ? _builder.Version : (-1));
				_current = null;
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				stack.ClearFastWhenEmpty();
				PushNext(_root);
			}

			private void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void ThrowIfChanged()
			{
				if (_builder != null && _builder.Version != _enumeratingBuilderVersion)
				{
					throw new InvalidOperationException(System.SR.CollectionModifiedDuringEnumeration);
				}
			}

			private void PushNext(Node node)
			{
				Requires.NotNull(node, "node");
				Stack<RefAsValueType<Node>> stack = _stack.Use(ref this);
				while (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<Node>(node));
					node = (_reverse ? node.Right : node.Left);
				}
			}
		}

		[DebuggerDisplay("{_key}")]
		internal sealed class Node : IBinaryTree<T>, IBinaryTree, IEnumerable<T>, IEnumerable
		{
			internal static readonly Node EmptyNode = new Node();

			private readonly T _key;

			private bool _frozen;

			private byte _height;

			private int _count;

			private Node _left;

			private Node _right;

			public bool IsEmpty => _left == null;

			public int Height => _height;

			public Node Left => _left;

			IBinaryTree IBinaryTree.Left => _left;

			public Node Right => _right;

			IBinaryTree IBinaryTree.Right => _right;

			IBinaryTree<T> IBinaryTree<T>.Left => _left;

			IBinaryTree<T> IBinaryTree<T>.Right => _right;

			public T Value => _key;

			public int Count => _count;

			internal T Key => _key;

			internal T Max
			{
				get
				{
					if (IsEmpty)
					{
						return default(T);
					}
					Node node = this;
					while (!node._right.IsEmpty)
					{
						node = node._right;
					}
					return node._key;
				}
			}

			internal T Min
			{
				get
				{
					if (IsEmpty)
					{
						return default(T);
					}
					Node node = this;
					while (!node._left.IsEmpty)
					{
						node = node._left;
					}
					return node._key;
				}
			}

			internal T this[int index]
			{
				get
				{
					Requires.Range(index >= 0 && index < Count, "index");
					if (index < _left._count)
					{
						return _left[index];
					}
					if (index > _left._count)
					{
						return _right[index - _left._count - 1];
					}
					return _key;
				}
			}

			private Node()
			{
				_frozen = true;
			}

			private Node(T key, Node left, Node right, bool frozen = false)
			{
				Requires.NotNull(left, "left");
				Requires.NotNull(right, "right");
				_key = key;
				_left = left;
				_right = right;
				_height = checked((byte)(1 + Math.Max(left._height, right._height)));
				_count = 1 + left._count + right._count;
				_frozen = frozen;
			}

			[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
			internal ref T ItemRef(int index)
			{
				Requires.Range(index >= 0 && index < Count, "index");
				if (index < _left._count)
				{
					return ref _left.ItemRef(index);
				}
				if (index > _left._count)
				{
					return ref _right.ItemRef(index - _left._count - 1);
				}
				return ref _key;
			}

			public Enumerator GetEnumerator()
			{
				return new Enumerator(this);
			}

			[ExcludeFromCodeCoverage]
			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return GetEnumerator();
			}

			[ExcludeFromCodeCoverage]
			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}

			internal Enumerator GetEnumerator(Builder builder)
			{
				return new Enumerator(this, builder);
			}

			internal void CopyTo(T[] array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array[arrayIndex++] = current;
				}
			}

			internal void CopyTo(Array array, int arrayIndex)
			{
				Requires.NotNull(array, "array");
				Requires.Range(arrayIndex >= 0, "arrayIndex");
				Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					array.SetValue(current, arrayIndex++);
				}
			}

			internal Node Add(T key, IComparer<T> comparer, out bool mutated)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					mutated = true;
					return new Node(key, this, this);
				}
				Node node = this;
				int num = comparer.Compare(key, _key);
				if (num > 0)
				{
					Node right = _right.Add(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(null, right);
					}
				}
				else
				{
					if (num >= 0)
					{
						mutated = false;
						return this;
					}
					Node left = _left.Add(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				if (!mutated)
				{
					return node;
				}
				return MakeBalanced(node);
			}

			internal Node Remove(T key, IComparer<T> comparer, out bool mutated)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					mutated = false;
					return this;
				}
				Node node = this;
				int num = comparer.Compare(key, _key);
				if (num == 0)
				{
					mutated = true;
					if (_right.IsEmpty && _left.IsEmpty)
					{
						node = EmptyNode;
					}
					else if (_right.IsEmpty && !_left.IsEmpty)
					{
						node = _left;
					}
					else if (!_right.IsEmpty && _left.IsEmpty)
					{
						node = _right;
					}
					else
					{
						Node node2 = _right;
						while (!node2._left.IsEmpty)
						{
							node2 = node2._left;
						}
						bool mutated2;
						Node right = _right.Remove(node2._key, comparer, out mutated2);
						node = node2.Mutate(_left, right);
					}
				}
				else if (num < 0)
				{
					Node left = _left.Remove(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(left);
					}
				}
				else
				{
					Node right2 = _right.Remove(key, comparer, out mutated);
					if (mutated)
					{
						node = Mutate(null, right2);
					}
				}
				if (!node.IsEmpty)
				{
					return MakeBalanced(node);
				}
				return node;
			}

			internal bool Contains(T key, IComparer<T> comparer)
			{
				Requires.NotNull(comparer, "comparer");
				return !Search(key, comparer).IsEmpty;
			}

			internal void Freeze()
			{
				if (!_frozen)
				{
					_left.Freeze();
					_right.Freeze();
					_frozen = true;
				}
			}

			internal Node Search(T key, IComparer<T> comparer)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					return this;
				}
				int num = comparer.Compare(key, _key);
				if (num == 0)
				{
					return this;
				}
				if (num > 0)
				{
					return _right.Search(key, comparer);
				}
				return _left.Search(key, comparer);
			}

			internal int IndexOf(T key, IComparer<T> comparer)
			{
				Requires.NotNull(comparer, "comparer");
				if (IsEmpty)
				{
					return -1;
				}
				int num = comparer.Compare(key, _key);
				if (num == 0)
				{
					return _left.Count;
				}
				if (num > 0)
				{
					int num2 = _right.IndexOf(key, comparer);
					bool flag = num2 < 0;
					if (flag)
					{
						num2 = ~num2;
					}
					num2 = _left.Count + 1 + num2;
					if (flag)
					{
						num2 = ~num2;
					}
					return num2;
				}
				return _left.IndexOf(key, comparer);
			}

			internal IEnumerator<T> Reverse()
			{
				return new Enumerator(this, null, reverse: true);
			}

			private static Node RotateLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				Node right = tree._right;
				return right.Mutate(tree.Mutate(null, right._left));
			}

			private static Node RotateRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				Node left = tree._left;
				return left.Mutate(null, tree.Mutate(left._right));
			}

			private static Node DoubleLeft(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._right.IsEmpty)
				{
					return tree;
				}
				Node tree2 = tree.Mutate(null, RotateRight(tree._right));
				return RotateLeft(tree2);
			}

			private static Node DoubleRight(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (tree._left.IsEmpty)
				{
					return tree;
				}
				Node tree2 = tree.Mutate(RotateLeft(tree._left));
				return RotateRight(tree2);
			}

			private static int Balance(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return tree._right._height - tree._left._height;
			}

			private static bool IsRightHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) >= 2;
			}

			private static bool IsLeftHeavy(Node tree)
			{
				Requires.NotNull(tree, "tree");
				return Balance(tree) <= -2;
			}

			private static Node MakeBalanced(Node tree)
			{
				Requires.NotNull(tree, "tree");
				if (IsRightHeavy(tree))
				{
					if (Balance(tree._right) >= 0)
					{
						return RotateLeft(tree);
					}
					return DoubleLeft(tree);
				}
				if (IsLeftHeavy(tree))
				{
					if (Balance(tree._left) <= 0)
					{
						return RotateRight(tree);
					}
					return DoubleRight(tree);
				}
				return tree;
			}

			internal static Node NodeTreeFromList(IOrderedCollection<T> items, int start, int length)
			{
				Requires.NotNull(items, "items");
				if (length == 0)
				{
					return EmptyNode;
				}
				int num = (length - 1) / 2;
				int num2 = length - 1 - num;
				Node left = NodeTreeFromList(items, start, num2);
				Node right = NodeTreeFromList(items, start + num2 + 1, num);
				return new Node(items[start + num2], left, right, frozen: true);
			}

			private Node Mutate(Node left = null, Node right = null)
			{
				if (_frozen)
				{
					return new Node(_key, left ?? _left, right ?? _right);
				}
				if (left != null)
				{
					_left = left;
				}
				if (right != null)
				{
					_right = right;
				}
				_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));
				_count = 1 + _left._count + _right._count;
				return this;
			}
		}

		private const float RefillOverIncrementalThreshold = 0.15f;

		public static readonly ImmutableSortedSet<T> Empty = new ImmutableSortedSet<T>();

		private readonly Node _root;

		private readonly IComparer<T> _comparer;

		public T Max => _root.Max;

		public T Min => _root.Min;

		public bool IsEmpty => _root.IsEmpty;

		public int Count => _root.Count;

		public IComparer<T> KeyComparer => _comparer;

		internal IBinaryTree Root => _root;

		public T this[int index] => _root.ItemRef(index);

		bool ICollection<T>.IsReadOnly => true;

		T IList<T>.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		bool IList.IsFixedSize => true;

		bool IList.IsReadOnly => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		object IList.this[int index]
		{
			get
			{
				return this[index];
			}
			set
			{
				throw new NotSupportedException();
			}
		}

		internal ImmutableSortedSet(IComparer<T> comparer = null)
		{
			_root = Node.EmptyNode;
			_comparer = comparer ?? Comparer<T>.Default;
		}

		private ImmutableSortedSet(Node root, IComparer<T> comparer)
		{
			Requires.NotNull(root, "root");
			Requires.NotNull(comparer, "comparer");
			root.Freeze();
			_root = root;
			_comparer = comparer;
		}

		public ImmutableSortedSet<T> Clear()
		{
			if (!_root.IsEmpty)
			{
				return Empty.WithComparer(_comparer);
			}
			return this;
		}

		[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		public ref T ItemRef(int index)
		{
			return ref _root.ItemRef(index);
		}

		public Builder ToBuilder()
		{
			return new Builder(this);
		}

		public ImmutableSortedSet<T> Add(T value)
		{
			bool mutated;
			return Wrap(_root.Add(value, _comparer, out mutated));
		}

		public ImmutableSortedSet<T> Remove(T value)
		{
			bool mutated;
			return Wrap(_root.Remove(value, _comparer, out mutated));
		}

		public bool TryGetValue(T equalValue, out T actualValue)
		{
			Node node = _root.Search(equalValue, _comparer);
			if (node.IsEmpty)
			{
				actualValue = equalValue;
				return false;
			}
			actualValue = node.Key;
			return true;
		}

		public ImmutableSortedSet<T> Intersect(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			ImmutableSortedSet<T> immutableSortedSet = Clear();
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item))
				{
					immutableSortedSet = immutableSortedSet.Add(item);
				}
			}
			return immutableSortedSet;
		}

		public ImmutableSortedSet<T> Except(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			Node node = _root;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				node = node.Remove(item, _comparer, out var _);
			}
			return Wrap(node);
		}

		public ImmutableSortedSet<T> SymmetricExcept(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			ImmutableSortedSet<T> immutableSortedSet = ImmutableSortedSet.CreateRange(_comparer, other);
			ImmutableSortedSet<T> immutableSortedSet2 = Clear();
			using (Enumerator enumerator = GetEnumerator())
			{
				while (enumerator.MoveNext())
				{
					T current = enumerator.Current;
					if (!immutableSortedSet.Contains(current))
					{
						immutableSortedSet2 = immutableSortedSet2.Add(current);
					}
				}
			}
			foreach (T item in immutableSortedSet)
			{
				if (!Contains(item))
				{
					immutableSortedSet2 = immutableSortedSet2.Add(item);
				}
			}
			return immutableSortedSet2;
		}

		public ImmutableSortedSet<T> Union(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (TryCastToImmutableSortedSet(other, out var other2) && other2.KeyComparer == KeyComparer)
			{
				if (other2.IsEmpty)
				{
					return this;
				}
				if (IsEmpty)
				{
					return other2;
				}
				if (other2.Count > Count)
				{
					return other2.Union(this);
				}
			}
			if (IsEmpty || (other.TryGetCount(out var count) && (float)(Count + count) * 0.15f > (float)Count))
			{
				return LeafToRootRefill(other);
			}
			return UnionIncremental(other);
		}

		public ImmutableSortedSet<T> WithComparer(IComparer<T> comparer)
		{
			if (comparer == null)
			{
				comparer = Comparer<T>.Default;
			}
			if (comparer == _comparer)
			{
				return this;
			}
			ImmutableSortedSet<T> immutableSortedSet = new ImmutableSortedSet<T>(Node.EmptyNode, comparer);
			return immutableSortedSet.Union(this);
		}

		public bool SetEquals(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (this == other)
			{
				return true;
			}
			SortedSet<T> sortedSet = new SortedSet<T>(other, KeyComparer);
			if (Count != sortedSet.Count)
			{
				return false;
			}
			int num = 0;
			foreach (T item in sortedSet)
			{
				if (!Contains(item))
				{
					return false;
				}
				num++;
			}
			return num == Count;
		}

		public bool IsProperSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return other.Any();
			}
			SortedSet<T> sortedSet = new SortedSet<T>(other, KeyComparer);
			if (Count >= sortedSet.Count)
			{
				return false;
			}
			int num = 0;
			bool flag = false;
			foreach (T item in sortedSet)
			{
				if (Contains(item))
				{
					num++;
				}
				else
				{
					flag = true;
				}
				if (num == Count && flag)
				{
					return true;
				}
			}
			return false;
		}

		public bool IsProperSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return false;
			}
			int num = 0;
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				num++;
				if (!Contains(item))
				{
					return false;
				}
			}
			return Count > num;
		}

		public bool IsSubsetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return true;
			}
			SortedSet<T> sortedSet = new SortedSet<T>(other, KeyComparer);
			int num = 0;
			foreach (T item in sortedSet)
			{
				if (Contains(item))
				{
					num++;
				}
			}
			return num == Count;
		}

		public bool IsSupersetOf(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (!Contains(item))
				{
					return false;
				}
			}
			return true;
		}

		public bool Overlaps(IEnumerable<T> other)
		{
			Requires.NotNull(other, "other");
			if (IsEmpty)
			{
				return false;
			}
			foreach (T item in other.GetEnumerableDisposable<T, Enumerator>())
			{
				if (Contains(item))
				{
					return true;
				}
			}
			return false;
		}

		public IEnumerable<T> Reverse()
		{
			return new ReverseEnumerable(_root);
		}

		public int IndexOf(T item)
		{
			return _root.IndexOf(item, _comparer);
		}

		public bool Contains(T value)
		{
			return _root.Contains(value, _comparer);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Clear()
		{
			return Clear();
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Add(T value)
		{
			return Add(value);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Remove(T value)
		{
			return Remove(value);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Intersect(IEnumerable<T> other)
		{
			return Intersect(other);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Except(IEnumerable<T> other)
		{
			return Except(other);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.SymmetricExcept(IEnumerable<T> other)
		{
			return SymmetricExcept(other);
		}

		[ExcludeFromCodeCoverage]
		IImmutableSet<T> IImmutableSet<T>.Union(IEnumerable<T> other)
		{
			return Union(other);
		}

		bool ISet<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.ExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.IntersectWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.SymmetricExceptWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ISet<T>.UnionWith(IEnumerable<T> other)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.CopyTo(T[] array, int arrayIndex)
		{
			_root.CopyTo(array, arrayIndex);
		}

		void ICollection<T>.Add(T item)
		{
			throw new NotSupportedException();
		}

		void ICollection<T>.Clear()
		{
			throw new NotSupportedException();
		}

		bool ICollection<T>.Remove(T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.Insert(int index, T item)
		{
			throw new NotSupportedException();
		}

		void IList<T>.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		int IList.Add(object value)
		{
			throw new NotSupportedException();
		}

		void IList.Clear()
		{
			throw new NotSupportedException();
		}

		bool IList.Contains(object value)
		{
			return Contains((T)value);
		}

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

		void IList.Insert(int index, object value)
		{
			throw new NotSupportedException();
		}

		void IList.Remove(object value)
		{
			throw new NotSupportedException();
		}

		void IList.RemoveAt(int index)
		{
			throw new NotSupportedException();
		}

		void ICollection.CopyTo(Array array, int index)
		{
			_root.CopyTo(array, index);
		}

		[ExcludeFromCodeCoverage]
		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return GetEnumerator();
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		[ExcludeFromCodeCoverage]
		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		public Enumerator GetEnumerator()
		{
			return _root.GetEnumerator();
		}

		private static bool TryCastToImmutableSortedSet(IEnumerable<T> sequence, out ImmutableSortedSet<T> other)
		{
			other = sequence as ImmutableSortedSet<T>;
			if (other != null)
			{
				return true;
			}
			if (sequence is Builder builder)
			{
				other = builder.ToImmutable();
				return true;
			}
			return false;
		}

		private static ImmutableSortedSet<T> Wrap(Node root, IComparer<T> comparer)
		{
			if (!root.IsEmpty)
			{
				return new ImmutableSortedSet<T>(root, comparer);
			}
			return Empty.WithComparer(comparer);
		}

		private ImmutableSortedSet<T> UnionIncremental(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			Node node = _root;
			foreach (T item in items.GetEnumerableDisposable<T, Enumerator>())
			{
				node = node.Add(item, _comparer, out var _);
			}
			return Wrap(node);
		}

		private ImmutableSortedSet<T> Wrap(Node root)
		{
			if (root != _root)
			{
				if (!root.IsEmpty)
				{
					return new ImmutableSortedSet<T>(root, _comparer);
				}
				return Clear();
			}
			return this;
		}

		private ImmutableSortedSet<T> LeafToRootRefill(IEnumerable<T> addedItems)
		{
			Requires.NotNull(addedItems, "addedItems");
			List<T> list;
			if (IsEmpty)
			{
				if (addedItems.TryGetCount(out var count) && count == 0)
				{
					return this;
				}
				list = new List<T>(addedItems);
				if (list.Count == 0)
				{
					return this;
				}
			}
			else
			{
				list = new List<T>(this);
				list.AddRange(addedItems);
			}
			IComparer<T> keyComparer = KeyComparer;
			list.Sort(keyComparer);
			int num = 1;
			for (int i = 1; i < list.Count; i++)
			{
				if (keyComparer.Compare(list[i], list[i - 1]) != 0)
				{
					list[num++] = list[i];
				}
			}
			list.RemoveRange(num, list.Count - num);
			Node root = Node.NodeTreeFromList(list.AsOrderedCollection(), 0, list.Count);
			return Wrap(root);
		}
	}
	internal class ImmutableSortedSetBuilderDebuggerProxy<T>
	{
		private readonly ImmutableSortedSet<T>.Builder _set;

		[DebuggerBrowsable(DebuggerBrowsableState.RootHidden)]
		public T[] Contents => _set.ToArray(_set.Count);

		public ImmutableSortedSetBuilderDebuggerProxy(ImmutableSortedSet<T>.Builder builder)
		{
			Requires.NotNull(builder, "builder");
			_set = builder;
		}
	}
	internal static class ImmutableStack
	{
		public static ImmutableStack<T> Create<T>()
		{
			return ImmutableStack<T>.Empty;
		}

		public static ImmutableStack<T> Create<T>(T item)
		{
			return ImmutableStack<T>.Empty.Push(item);
		}

		public static ImmutableStack<T> CreateRange<T>(IEnumerable<T> items)
		{
			Requires.NotNull(items, "items");
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			foreach (T item in items)
			{
				immutableStack = immutableStack.Push(item);
			}
			return immutableStack;
		}

		public static ImmutableStack<T> Create<T>(params T[] items)
		{
			Requires.NotNull(items, "items");
			ImmutableStack<T> immutableStack = ImmutableStack<T>.Empty;
			foreach (T value in items)
			{
				immutableStack = immutableStack.Push(value);
			}
			return immutableStack;
		}

		public static IImmutableStack<T> Pop<T>(this IImmutableStack<T> stack, out T value)
		{
			Requires.NotNull(stack, "stack");
			value = stack.Peek();
			return stack.Pop();
		}
	}
	[DebuggerTypeProxy(typeof(ImmutableEnumerableDebuggerProxy<>))]
	[DebuggerDisplay("IsEmpty = {IsEmpty}; Top = {_head}")]
	internal sealed class ImmutableStack<T> : IImmutableStack<T>, IEnumerable<T>, IEnumerable
	{
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator
		{
			private readonly ImmutableStack<T> _originalStack;

			private ImmutableStack<T> _remainingStack;

			public T Current
			{
				get
				{
					if (_remainingStack == null || _remainingStack.IsEmpty)
					{
						throw new InvalidOperationException();
					}
					return _remainingStack.Peek();
				}
			}

			internal Enumerator(ImmutableStack<T> stack)
			{
				Requires.NotNull(stack, "stack");
				_originalStack = stack;
				_remainingStack = null;
			}

			public bool MoveNext()
			{
				if (_remainingStack == null)
				{
					_remainingStack = _originalStack;
				}
				else if (!_remainingStack.IsEmpty)
				{
					_remainingStack = _remainingStack.Pop();
				}
				return !_remainingStack.IsEmpty;
			}
		}

		private class EnumeratorObject : IEnumerator<T>, IDisposable, IEnumerator
		{
			private readonly ImmutableStack<T> _originalStack;

			private ImmutableStack<T> _remainingStack;

			private bool _disposed;

			public T Current
			{
				get
				{
					ThrowIfDisposed();
					if (_remainingStack == null || _remainingStack.IsEmpty)
					{
						throw new InvalidOperationException();
					}
					return _remainingStack.Peek();
				}
			}

			object IEnumerator.Current => Current;

			internal EnumeratorObject(ImmutableStack<T> stack)
			{
				Requires.NotNull(stack, "stack");
				_originalStack = stack;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				if (_remainingStack == null)
				{
					_remainingStack = _originalStack;
				}
				else if (!_remainingStack.IsEmpty)
				{
					_remainingStack = _remainingStack.Pop();
				}
				return !_remainingStack.IsEmpty;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_remainingStack = null;
			}

			public void Dispose()
			{
				_disposed = true;
			}

			private void ThrowIfDisposed()
			{
				if (_disposed)
				{
					Requires.FailObjectDisposed(this);
				}
			}
		}

		private static readonly ImmutableStack<T> s_EmptyField = new ImmutableStack<T>();

		private readonly T _head;

		private readonly ImmutableStack<T> _tail;

		public static ImmutableStack<T> Empty => s_EmptyField;

		public bool IsEmpty => _tail == null;

		private ImmutableStack()
		{
		}

		private ImmutableStack(T head, ImmutableStack<T> tail)
		{
			_head = head;
			_tail = tail;
		}

		public ImmutableStack<T> Clear()
		{
			return Empty;
		}

		IImmutableStack<T> IImmutableStack<T>.Clear()
		{
			return Clear();
		}

		public T Peek()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return _head;
		}

		[return: <d35e620b-1b9e-4308-a9e3-86436c87737a>IsReadOnly]
		public ref T PeekRef()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return ref _head;
		}

		public ImmutableStack<T> Push(T value)
		{
			return new ImmutableStack<T>(value, this);
		}

		IImmutableStack<T> IImmutableStack<T>.Push(T value)
		{
			return Push(value);
		}

		public ImmutableStack<T> Pop()
		{
			if (IsEmpty)
			{
				throw new InvalidOperationException(System.SR.InvalidEmptyOperation);
			}
			return _tail;
		}

		public ImmutableStack<T> Pop(out T value)
		{
			value = Peek();
			return Pop();
		}

		IImmutableStack<T> IImmutableStack<T>.Pop()
		{
			return Pop();
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		IEnumerator<T> IEnumerable<T>.GetEnumerator()
		{
			if (!IsEmpty)
			{
				return new EnumeratorObject(this);
			}
			return Enumerable.Empty<T>().GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new EnumeratorObject(this);
		}

		internal ImmutableStack<T> Reverse()
		{
			ImmutableStack<T> immutableStack = Clear();
			ImmutableStack<T> immutableStack2 = this;
			while (!immutableStack2.IsEmpty)
			{
				immutableStack = immutableStack.Push(immutableStack2.Peek());
				immutableStack2 = immutableStack2.Pop();
			}
			return immutableStack;
		}
	}
	internal abstract class KeysOrValuesCollectionAccessor<TKey, TValue, T> : ICollection<T>, IEnumerable<T>, IEnumerable, ICollection
	{
		private readonly IImmutableDictionary<TKey, TValue> _dictionary;

		private readonly IEnumerable<T> _keysOrValues;

		public bool IsReadOnly => true;

		public int Count => _dictionary.Count;

		protected IImmutableDictionary<TKey, TValue> Dictionary => _dictionary;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		bool ICollection.IsSynchronized => true;

		[DebuggerBrowsable(DebuggerBrowsableState.Never)]
		object ICollection.SyncRoot => this;

		protected KeysOrValuesCollectionAccessor(IImmutableDictionary<TKey, TValue> dictionary, IEnumerable<T> keysOrValues)
		{
			Requires.NotNull(dictionary, "dictionary");
			Requires.NotNull(keysOrValues, "keysOrValues");
			_dictionary = dictionary;
			_keysOrValues = keysOrValues;
		}

		public void Add(T item)
		{
			throw new NotSupportedException();
		}

		public void Clear()
		{
			throw new NotSupportedException();
		}

		public abstract bool Contains(T item);

		public void CopyTo(T[] array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using IEnumerator<T> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array[arrayIndex++] = current;
			}
		}

		public bool Remove(T item)
		{
			throw new NotSupportedException();
		}

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

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		void ICollection.CopyTo(Array array, int arrayIndex)
		{
			Requires.NotNull(array, "array");
			Requires.Range(arrayIndex >= 0, "arrayIndex");
			Requires.Range(array.Length >= arrayIndex + Count, "arrayIndex");
			using IEnumerator<T> enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				T current = enumerator.Current;
				array.SetValue(current, arrayIndex++);
			}
		}
	}
	internal sealed class KeysCollectionAccessor<TKey, TValue> : KeysOrValuesCollectionAccessor<TKey, TValue, TKey>
	{
		internal KeysCollectionAccessor(IImmutableDictionary<TKey, TValue> dictionary)
			: base(dictionary, dictionary.Keys)
		{
		}

		public override bool Contains(TKey item)
		{
			return base.Dictionary.ContainsKey(item);
		}
	}
	internal sealed class ValuesCollectionAccessor<TKey, TValue> : KeysOrValuesCollectionAccessor<TKey, TValue, TValue>
	{
		internal ValuesCollectionAccessor(IImmutableDictionary<TKey, TValue> dictionary)
			: base(dictionary, dictionary.Values)
		{
		}

		public override bool Contains(TValue item)
		{
			if (base.Dictionary is ImmutableSortedDictionary<TKey, TValue> immutableSortedDictionary)
			{
				return immutableSortedDictionary.ContainsValue(item);
			}
			if (base.Dictionary is IImmutableDictionaryInternal<TKey, TValue> immutableDictionaryInternal)
			{
				return immutableDictionaryInternal.ContainsValue(item);
			}
			throw new NotSupportedException();
		}
	}
	[DebuggerDisplay("{Value,nq}")]
	internal struct RefAsValueType<T>
	{
		internal T Value;

		internal RefAsValueType(T value)
		{
			Value = value;
		}
	}
	internal class SecureObjectPool
	{
		private static int s_poolUserIdCounter;

		internal const int UnassignedId = -1;

		internal static int NewId()
		{
			int num;
			do
			{
				num = Interlocked.Increment(ref s_poolUserIdCounter);
			}
			while (num == -1);
			return num;
		}
	}
	internal class SecureObjectPool<T, TCaller> where TCaller : ISecurePooledObjectUser
	{
		public void TryAdd(TCaller caller, SecurePooledObject<T> item)
		{
			if (caller.PoolUserId == item.Owner)
			{
				item.Owner = -1;
				AllocFreeConcurrentStack<SecurePooledObject<T>>.TryAdd(item);
			}
		}

		public bool TryTake(TCaller caller, out SecurePooledObject<T> item)
		{
			if (caller.PoolUserId != -1 && AllocFreeConcurrentStack<SecurePooledObject<T>>.TryTake(out item))
			{
				item.Owner = caller.PoolUserId;
				return true;
			}
			item = null;
			return false;
		}

		public SecurePooledObject<T> PrepNew(TCaller caller, T newValue)
		{
			Requires.NotNullAllowStructs(newValue, "newValue");
			SecurePooledObject<T> securePooledObject = new SecurePooledObject<T>(newValue);
			securePooledObject.Owner = caller.PoolUserId;
			return securePooledObject;
		}
	}
	internal interface ISecurePooledObjectUser
	{
		int PoolUserId { get; }
	}
	internal class SecurePooledObject<T>
	{
		private readonly T _value;

		private int _owner;

		internal int Owner
		{
			get
			{
				return _owner;
			}
			set
			{
				_owner = value;
			}
		}

		internal SecurePooledObject(T newValue)
		{
			Requires.NotNullAllowStructs(newValue, "newValue");
			_value = newValue;
		}

		internal T Use<TCaller>(ref TCaller caller) where TCaller : struct, ISecurePooledObjectUser
		{
			if (!IsOwned(ref caller))
			{
				Requires.FailObjectDisposed(caller);
			}
			return _value;
		}

		internal bool TryUse<TCaller>(ref TCaller caller, out T value) where TCaller : struct, ISecurePooledObjectUser
		{
			if (IsOwned(ref caller))
			{
				value = _value;
				return true;
			}
			value = default(T);
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal bool IsOwned<TCaller>(ref TCaller caller) where TCaller : struct, ISecurePooledObjectUser
		{
			return caller.PoolUserId == _owner;
		}
	}
	[DebuggerDisplay("{_key} = {_value}")]
	internal sealed class SortedInt32KeyNode<TValue> : IBinaryTree
	{
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public struct Enumerator : IEnumerator<KeyValuePair<int, TValue>>, IDisposable, IEnumerator, ISecurePooledObjectUser
		{
			private static readonly SecureObjectPool<Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>, Enumerator> s_enumeratingStacks = new SecureObjectPool<Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>, Enumerator>();

			private readonly int _poolUserId;

			private SortedInt32KeyNode<TValue> _root;

			private SecurePooledObject<Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>> _stack;

			private SortedInt32KeyNode<TValue> _current;

			public KeyValuePair<int, TValue> Current
			{
				get
				{
					ThrowIfDisposed();
					if (_current != null)
					{
						return _current.Value;
					}
					throw new InvalidOperationException();
				}
			}

			int ISecurePooledObjectUser.PoolUserId => _poolUserId;

			object IEnumerator.Current => Current;

			internal Enumerator(SortedInt32KeyNode<TValue> root)
			{
				Requires.NotNull(root, "root");
				_root = root;
				_current = null;
				_poolUserId = SecureObjectPool.NewId();
				_stack = null;
				if (!_root.IsEmpty)
				{
					if (!s_enumeratingStacks.TryTake(this, out _stack))
					{
						_stack = s_enumeratingStacks.PrepNew(this, new Stack<RefAsValueType<SortedInt32KeyNode<TValue>>>(root.Height));
					}
					PushLeft(_root);
				}
			}

			public void Dispose()
			{
				_root = null;
				_current = null;
				if (_stack != null && _stack.TryUse(ref this, out var value))
				{
					value.ClearFastWhenEmpty();
					s_enumeratingStacks.TryAdd(this, _stack);
				}
				_stack = null;
			}

			public bool MoveNext()
			{
				ThrowIfDisposed();
				if (_stack != null)
				{
					Stack<RefAsValueType<SortedInt32KeyNode<TValue>>> stack = _stack.Use(ref this);
					if (stack.Count > 0)
					{
						PushLeft((_current = stack.Pop().Value).Right);
						return true;
					}
				}
				_current = null;
				return false;
			}

			public void Reset()
			{
				ThrowIfDisposed();
				_current = null;
				if (_stack != null)
				{
					Stack<RefAsValueType<SortedInt32KeyNode<TValue>>> stack = _stack.Use(ref this);
					stack.ClearFastWhenEmpty();
					PushLeft(_root);
				}
			}

			internal void ThrowIfDisposed()
			{
				if (_root == null || (_stack != null && !_stack.IsOwned(ref this)))
				{
					Requires.FailObjectDisposed(this);
				}
			}

			private void PushLeft(SortedInt32KeyNode<TValue> node)
			{
				Requires.NotNull(node, "node");
				Stack<RefAsValueType<SortedInt32KeyNode<TValue>>> stack = _stack.Use(ref this);
				while (!node.IsEmpty)
				{
					stack.Push(new RefAsValueType<SortedInt32KeyNode<TValue>>(node));
					node = node.Left;
				}
			}
		}

		internal static readonly SortedInt32KeyNode<TValue> EmptyNode = new SortedInt32KeyNode<TValue>();

		private readonly int _key;

		private readonly TValue _value;

		private bool _frozen;

		private byte _height;

		private SortedInt32KeyNode<TValue> _left;

		private SortedInt32KeyNode<TValue> _right;

		public bool IsEmpty => _left == null;

		public int Height => _height;

		public SortedInt32KeyNode<TValue> Left => _left;

		public SortedInt32KeyNode<TValue> Right => _right;

		IBinaryTree IBinaryTree.Left => _left;

		IBinaryTree IBinaryTree.Right => _right;

		int IBinaryTree.Count
		{
			get
			{
				throw new NotSupportedException();
			}
		}

		public KeyValuePair<int, TValue> Value => new KeyValuePair<int, TValue>(_key, _value);

		internal IEnumerable<TValue> Values
		{
			get
			{
				using Enumerator enumerator = GetEnumerator();
				while (enumerator.MoveNext())
				{
					yield return enumerator.Current.Value;
				}
			}
		}

		private SortedInt32KeyNode()
		{
			_frozen = true;
		}

		private SortedInt32KeyNode(int key, TValue value, SortedInt32KeyNode<TValue> left, SortedInt32KeyNode<TValue> right, bool frozen = false)
		{
			Requires.NotNull(left, "left");
			Requires.NotNull(right, "right");
			_key = key;
			_value = value;
			_left = left;
			_right = right;
			_frozen = frozen;
			_height = checked((byte)(1 + Math.Max(left._height, right._height)));
		}

		public Enumerator GetEnumerator()
		{
			return new Enumerator(this);
		}

		internal SortedInt32KeyNode<TValue> SetItem(int key, TValue value, IEqualityComparer<TValue> valueComparer, out bool replacedExistingValue, out bool mutated)
		{
			Requires.NotNull(valueComparer, "valueComparer");
			return SetOrAdd(key, value, valueComparer, overwriteExistingValue: true, out replacedExistingValue, out mutated);
		}

		internal SortedInt32KeyNode<TValue> Remove(int key, out bool mutated)
		{
			return RemoveRecursive(key, out mutated);
		}

		internal TValue GetValueOrDefault(int key)
		{
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			while (true)
			{
				if (sortedInt32KeyNode.IsEmpty)
				{
					return default(TValue);
				}
				if (key == sortedInt32KeyNode._key)
				{
					break;
				}
				sortedInt32KeyNode = ((key <= sortedInt32KeyNode._key) ? sortedInt32KeyNode._left : sortedInt32KeyNode._right);
			}
			return sortedInt32KeyNode._value;
		}

		internal bool TryGetValue(int key, out TValue value)
		{
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			while (true)
			{
				if (sortedInt32KeyNode.IsEmpty)
				{
					value = default(TValue);
					return false;
				}
				if (key == sortedInt32KeyNode._key)
				{
					break;
				}
				sortedInt32KeyNode = ((key <= sortedInt32KeyNode._key) ? sortedInt32KeyNode._left : sortedInt32KeyNode._right);
			}
			value = sortedInt32KeyNode._value;
			return true;
		}

		internal void Freeze(Action<KeyValuePair<int, TValue>> freezeAction = null)
		{
			if (!_frozen)
			{
				freezeAction?.Invoke(new KeyValuePair<int, TValue>(_key, _value));
				_left.Freeze(freezeAction);
				_right.Freeze(freezeAction);
				_frozen = true;
			}
		}

		private static SortedInt32KeyNode<TValue> RotateLeft(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._right.IsEmpty)
			{
				return tree;
			}
			SortedInt32KeyNode<TValue> right = tree._right;
			return right.Mutate(tree.Mutate(null, right._left));
		}

		private static SortedInt32KeyNode<TValue> RotateRight(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._left.IsEmpty)
			{
				return tree;
			}
			SortedInt32KeyNode<TValue> left = tree._left;
			return left.Mutate(null, tree.Mutate(left._right));
		}

		private static SortedInt32KeyNode<TValue> DoubleLeft(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._right.IsEmpty)
			{
				return tree;
			}
			SortedInt32KeyNode<TValue> tree2 = tree.Mutate(null, RotateRight(tree._right));
			return RotateLeft(tree2);
		}

		private static SortedInt32KeyNode<TValue> DoubleRight(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (tree._left.IsEmpty)
			{
				return tree;
			}
			SortedInt32KeyNode<TValue> tree2 = tree.Mutate(RotateLeft(tree._left));
			return RotateRight(tree2);
		}

		private static int Balance(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			return tree._right._height - tree._left._height;
		}

		private static bool IsRightHeavy(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			return Balance(tree) >= 2;
		}

		private static bool IsLeftHeavy(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			return Balance(tree) <= -2;
		}

		private static SortedInt32KeyNode<TValue> MakeBalanced(SortedInt32KeyNode<TValue> tree)
		{
			Requires.NotNull(tree, "tree");
			if (IsRightHeavy(tree))
			{
				if (Balance(tree._right) >= 0)
				{
					return RotateLeft(tree);
				}
				return DoubleLeft(tree);
			}
			if (IsLeftHeavy(tree))
			{
				if (Balance(tree._left) <= 0)
				{
					return RotateRight(tree);
				}
				return DoubleRight(tree);
			}
			return tree;
		}

		private SortedInt32KeyNode<TValue> SetOrAdd(int key, TValue value, IEqualityComparer<TValue> valueComparer, bool overwriteExistingValue, out bool replacedExistingValue, out bool mutated)
		{
			replacedExistingValue = false;
			if (IsEmpty)
			{
				mutated = true;
				return new SortedInt32KeyNode<TValue>(key, value, this, this);
			}
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			if (key > _key)
			{
				SortedInt32KeyNode<TValue> right = _right.SetOrAdd(key, value, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(null, right);
				}
			}
			else if (key < _key)
			{
				SortedInt32KeyNode<TValue> left = _left.SetOrAdd(key, value, valueComparer, overwriteExistingValue, out replacedExistingValue, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(left);
				}
			}
			else
			{
				if (valueComparer.Equals(_value, value))
				{
					mutated = false;
					return this;
				}
				if (!overwriteExistingValue)
				{
					throw new ArgumentException(System.SR.Format(System.SR.DuplicateKey, key));
				}
				mutated = true;
				replacedExistingValue = true;
				sortedInt32KeyNode = new SortedInt32KeyNode<TValue>(key, value, _left, _right);
			}
			if (!mutated)
			{
				return sortedInt32KeyNode;
			}
			return MakeBalanced(sortedInt32KeyNode);
		}

		private SortedInt32KeyNode<TValue> RemoveRecursive(int key, out bool mutated)
		{
			if (IsEmpty)
			{
				mutated = false;
				return this;
			}
			SortedInt32KeyNode<TValue> sortedInt32KeyNode = this;
			if (key == _key)
			{
				mutated = true;
				if (_right.IsEmpty && _left.IsEmpty)
				{
					sortedInt32KeyNode = EmptyNode;
				}
				else if (_right.IsEmpty && !_left.IsEmpty)
				{
					sortedInt32KeyNode = _left;
				}
				else if (!_right.IsEmpty && _left.IsEmpty)
				{
					sortedInt32KeyNode = _right;
				}
				else
				{
					SortedInt32KeyNode<TValue> sortedInt32KeyNode2 = _right;
					while (!sortedInt32KeyNode2._left.IsEmpty)
					{
						sortedInt32KeyNode2 = sortedInt32KeyNode2._left;
					}
					bool mutated2;
					SortedInt32KeyNode<TValue> right = _right.Remove(sortedInt32KeyNode2._key, out mutated2);
					sortedInt32KeyNode = sortedInt32KeyNode2.Mutate(_left, right);
				}
			}
			else if (key < _key)
			{
				SortedInt32KeyNode<TValue> left = _left.Remove(key, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(left);
				}
			}
			else
			{
				SortedInt32KeyNode<TValue> right2 = _right.Remove(key, out mutated);
				if (mutated)
				{
					sortedInt32KeyNode = Mutate(null, right2);
				}
			}
			if (!sortedInt32KeyNode.IsEmpty)
			{
				return MakeBalanced(sortedInt32KeyNode);
			}
			return sortedInt32KeyNode;
		}

		private SortedInt32KeyNode<TValue> Mutate(SortedInt32KeyNode<TValue> left = null, SortedInt32KeyNode<TValue> right = null)
		{
			if (_frozen)
			{
				return new SortedInt32KeyNode<TValue>(_key, _value, left ?? _left, right ?? _right);
			}
			if (left != null)
			{
				_left = left;
			}
			if (right != null)
			{
				_right = right;
			}
			_height = checked((byte)(1 + Math.Max(_left._height, _right._height)));
			return this;
		}
	}
	internal static class Requires
	{
		[DebuggerStepThrough]
		public static void NotNull<T>([ValidatedNotNull] T value, string parameterName) where T : class
		{
			if (value == null)
			{
				FailArgumentNullException(parameterName);
			}
		}

		[DebuggerStepThrough]
		public static T NotNullPassthrough<T>([ValidatedNotNull] T value, string parameterName) where T : class
		{
			NotNull(value, parameterName);
			return value;
		}

		[DebuggerStepThrough]
		public static void NotNullAllowStructs<T>([ValidatedNotNull] T value, string parameterName)
		{
			if (value == null)
			{
				FailArgumentNullException(parameterName);
			}
		}

		[DebuggerStepThrough]
		private static void FailArgumentNullException(string parameterName)
		{
			throw new ArgumentNullException(parameterName);
		}

		[DebuggerStepThrough]
		public static void Range(bool condition, string parameterName, string message = null)
		{
			if (!condition)
			{
				FailRange(parameterName, message);
			}
		}

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

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

		[DebuggerStepThrough]
		public static void Argument(bool condition)
		{
			if (!condition)
			{
				throw new ArgumentException();
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[DebuggerStepThrough]
		public static void FailObjectDisposed<TDisposed>(TDisposed disposed)
		{
			throw new ObjectDisposedException(disposed.GetType().FullName);
		}
	}
	[AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)]
	internal sealed class ValidatedNotNullAttribute : Attribute
	{
	}
}
namespace System.Collections.Generic
{
	internal interface IHashKeyCollection<in TKey>
	{
		IEqualityComparer<TKey> KeyComparer { get; }
	}
	internal interface ISortKeyCollection<in TKey>
	{
		IComparer<TKey> KeyComparer { get; }
	}
}
namespace System.Runtime.CompilerServices
{
	internal static class Unsafe
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static T Read<T>(void* source)
		{
			return Unsafe.Read<T>(source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static T ReadUnaligned<T>(void* source)
		{
			return Unsafe.ReadUnaligned<T>(source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static T ReadUnaligned<T>(ref byte source)
		{
			return Unsafe.ReadUnaligned<T>(ref source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void Write<T>(void* destination, T value)
		{
			Unsafe.Write(destination, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void WriteUnaligned<T>(void* destination, T value)
		{
			Unsafe.WriteUnaligned(destination, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static void WriteUnaligned<T>(ref byte destination, T value)
		{
			Unsafe.WriteUnaligned(ref destination, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void Copy<T>(void* destination, ref T source)
		{
			Unsafe.Write(destination, source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void Copy<T>(ref T destination, void* source)
		{
			destination = Unsafe.Read<T>(source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void* AsPointer<T>(ref T value)
		{
			return Unsafe.AsPointer(ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static int SizeOf<T>()
		{
			return Unsafe.SizeOf<T>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void CopyBlock(void* destination, void* source, uint byteCount)
		{
			// IL cpblk instruction
			Unsafe.CopyBlock(destination, source, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static void CopyBlock(ref byte destination, ref byte source, uint byteCount)
		{
			// IL cpblk instruction
			Unsafe.CopyBlock(ref destination, ref source, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void CopyBlockUnaligned(void* destination, void* source, uint byteCount)
		{
			// IL cpblk instruction
			Unsafe.CopyBlockUnaligned(destination, source, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static void CopyBlockUnaligned(ref byte destination, ref byte source, uint byteCount)
		{
			// IL cpblk instruction
			Unsafe.CopyBlockUnaligned(ref destination, ref source, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void InitBlock(void* startAddress, byte value, uint byteCount)
		{
			// IL initblk instruction
			Unsafe.InitBlock(startAddress, value, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static void InitBlock(ref byte startAddress, byte value, uint byteCount)
		{
			// IL initblk instruction
			Unsafe.InitBlock(ref startAddress, value, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void InitBlockUnaligned(void* startAddress, byte value, uint byteCount)
		{
			// IL initblk instruction
			Unsafe.InitBlockUnaligned(startAddress, value, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static void InitBlockUnaligned(ref byte startAddress, byte value, uint byteCount)
		{
			// IL initblk instruction
			Unsafe.InitBlockUnaligned(ref startAddress, value, byteCount);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static T As<T>(object o) where T : class
		{
			return (T)o;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static ref T AsRef<T>(void* source)
		{
			return ref *(T*)source;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref T AsRef<T>([<4f7fb1b7-68a5-49dd-a0ab-a9e53d5e6344>IsReadOnly] ref T source)
		{
			return ref source;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref TTo As<TFrom, TTo>(ref TFrom source)
		{
			return ref Unsafe.As<TFrom, TTo>(ref source);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref T Add<T>(ref T source, int elementOffset)
		{
			return ref Unsafe.Add(ref source, elementOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void* Add<T>(void* source, int elementOffset)
		{
			return (byte*)source + (nint)elementOffset * (nint)Unsafe.SizeOf<T>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref T Add<T>(ref T source, IntPtr elementOffset)
		{
			return ref Unsafe.Add(ref source, elementOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref T AddByteOffset<T>(ref T source, IntPtr byteOffset)
		{
			return ref Unsafe.AddByteOffset(ref source, byteOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref T Subtract<T>(ref T source, int elementOffset)
		{
			return ref Unsafe.Subtract(ref source, elementOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public unsafe static void* Subtract<T>(void* source, int elementOffset)
		{
			return (byte*)source - (nint)elementOffset * (nint)Unsafe.SizeOf<T>();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref T Subtract<T>(ref T source, IntPtr elementOffset)
		{
			return ref Unsafe.Subtract(ref source, elementOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static ref T SubtractByteOffset<T>(ref T source, IntPtr byteOffset)
		{
			return ref Unsafe.SubtractByteOffset(ref source, byteOffset);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static IntPtr ByteOffset<T>(ref T origin, ref T target)
		{
			return Unsafe.ByteOffset(target: ref target, origin: ref origin);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static bool AreSame<T>(ref T left, ref T right)
		{
			return Unsafe.AreSame(ref left, ref right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static bool IsAddressGreaterThan<T>(ref T left, ref T right)
		{
			return Unsafe.IsAddressGreaterThan(ref left, ref right);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[System.Runtime.Versioning.NonVersionable]
		public static bool IsAddressLessThan<T>(ref T left, ref T right)
		{
			return Unsafe.IsAddressLessThan(ref left, ref right);
		}
	}
}
namespace System.Runtime.Versioning
{
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class NonVersionableAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	internal sealed class <4f7fb1b7-68a5-49dd-a0ab-a9e53d5e6344>IsReadOnlyAttribute : Attribute
	{
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[<feaf9fe7-35ed-4304-8aea-1b88e21f2aed>Embedded]
	internal sealed class <feaf9fe7-35ed-4304-8aea-1b88e21f2aed>EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[<feaf9fe7-35ed-4304-8aea-1b88e21f2aed>Embedded]
	[CompilerGenerated]
	internal sealed class <da4ae7fc-788b-41bf-a5c9-fb56955443e9>IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[<feaf9fe7-35ed-4304-8aea-1b88e21f2aed>Embedded]
	internal sealed class <3ab5f816-f121-4279-90dc-7a65a54777ac>IsUnmanagedAttribute : Attribute
	{
	}
}
[ExcludeFromCodeCoverage]
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.5.119.9565")]
internal static class <a4555eb7-a827-48ec-afa8-7f1fb8261bcf>ThisAssembly
{
	internal const string AssemblyConfiguration = "Release";

	internal const string AssemblyFileVersion = "3.2.26.38424";

	internal const string AssemblyInformationalVersion = "3.2.26+9618de9414";

	internal const string AssemblyName = "protobuf-net";

	internal const string AssemblyTitle = "protobuf-net";

	internal const string AssemblyVersion = "3.0.0.0";

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

	internal const string GitCommitId = "9618de94145145228e115e8f134f132522e51f88";

	internal const bool IsPrerelease = false;

	internal const bool IsPublicRelease = true;

	internal const string PublicKey = "002400000480000094000000060200000024000052534131000400000100010009ed9caa457bfc205716c3d4e8b255a63ddf71c9e53b1b5f574ab6ffdba11e80ab4b50be9c46d43b75206280070ddba67bd4c830f93f0317504a76ba6a48243c36d2590695991164592767a7bbc4453b34694e31e20815a096e4483605139a32a76ec2fef196507487329c12047bf6a68bca8ee9354155f4d01daf6eec5ff6bc";

	internal const string PublicKeyToken = "257b51d87d2e4d67";

	internal const string RootNamespace = "ProtoBuf";
}
namespace ProtoBuf
{
	internal static class Serializer
	{
		public static class NonGeneric
		{
			public static object DeepClone(object instance)
			{
				if (instance != null)
				{
					return RuntimeTypeModel.Default.DeepClone(instance);
				}
				return null;
			}

			public static void Serialize(Stream dest, object instance)
			{
				if (instance != null)
				{
					ProtoWriter.State state = ProtoWriter.State.Create(dest, RuntimeTypeModel.Default);
					try
					{
						state.Model.SerializeRootFallback(ref state, instance);
					}
					finally
					{
						state.Dispose();
					}
				}
			}

			public static object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, Stream source)
			{
				return RuntimeTypeModel.Default.Deserialize(type, source, null, null, -1L);
			}

			public static object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, Stream source, object instance = null, object userState = null, long length = -1L)
			{
				return RuntimeTypeModel.Default.Deserialize(type, source, instance, userState, length);
			}

			public static object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ReadOnlyMemory<byte> source, object instance = null, object userState = null)
			{
				return RuntimeTypeModel.Default.Deserialize(type, source, instance, userState);
			}

			public static object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ReadOnlySequence<byte> source, object instance = null, object userState = null)
			{
				return RuntimeTypeModel.Default.Deserialize(type, source, instance, userState);
			}

			public static object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ReadOnlySpan<byte> source, object instance = null, object userState = null)
			{
				return RuntimeTypeModel.Default.Deserialize(type, source, instance, userState);
			}

			[EditorBrowsable(EditorBrowsableState.Never)]
			[Browsable(false)]
			public static object Merge(Stream source, object instance)
			{
				if (instance == null)
				{
					throw new ArgumentNullException("instance");
				}
				using ProtoReader.State state = ProtoReader.State.Create(source, RuntimeTypeModel.Default, null, -1L);
				return state.DeserializeRootFallback(instance, instance.GetType());
			}

			public static void SerializeWithLengthPrefix(Stream destination, object instance, PrefixStyle style, int fieldNumber)
			{
				if (instance == null)
				{
					throw new ArgumentNullException("instance");
				}
				RuntimeTypeModel.Default.SerializeWithLengthPrefix(destination, instance, instance.GetType(), style, fieldNumber);
			}

			public static bool TryDeserializeWithLengthPrefix(Stream source, PrefixStyle style, ProtoBuf.TypeResolver resolver, out object value)
			{
				value = RuntimeTypeModel.Default.DeserializeWithLengthPrefix(source, null, null, style, 0, resolver);
				return value != null;
			}

			public static bool CanSerialize(Type type)
			{
				return RuntimeTypeModel.Default.IsDefined(type);
			}

			public static void PrepareSerializer([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type)
			{
				RuntimeTypeModel.Default[type].CompileInPlace();
			}
		}

		public static class GlobalOptions
		{
			private static ProtoSyntax _defaultSyntax = ProtoSyntax.Proto3;

			[Obsolete("Please use RuntimeTypeModel.Default.InferTagFromNameDefault instead (or on a per-model basis)", false)]
			public static bool InferTagFromName
			{
				get
				{
					return RuntimeTypeModel.Default.InferTagFromNameDefault;
				}
				set
				{
					RuntimeTypeModel.Default.InferTagFromNameDefault = value;
				}
			}

			public static ProtoSyntax DefaultSyntax
			{
				get
				{
					return _defaultSyntax;
				}
				set
				{
					if ((uint)value <= 1u)
					{
						_defaultSyntax = value;
					}
					else
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("DefaultSyntax");
					}
				}
			}

			internal static ProtoSyntax Normalize(ProtoSyntax syntax)
			{
				return syntax switch
				{
					ProtoSyntax.Proto2 => syntax, 
					ProtoSyntax.Proto3 => syntax, 
					_ => DefaultSyntax, 
				};
			}
		}

		[Obsolete("Please use ProtoBuf.TypeResolver", true)]
		public delegate Type TypeResolver(int fieldNumber);

		private const string ProtoBinaryField = "proto";

		public const int ListItemTag = 1;

		public static string GetProto<T>()
		{
			return RuntimeTypeModel.Default.GetSchema(typeof(T), ProtoSyntax.Default);
		}

		public static string GetProto<T>(ProtoSyntax syntax)
		{
			return RuntimeTypeModel.Default.GetSchema(typeof(T), syntax);
		}

		public static string GetProto(SchemaGenerationOptions options)
		{
			return RuntimeTypeModel.Default.GetSchema(options);
		}

		public static T DeepClone<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T instance, SerializationContext context)
		{
			return RuntimeTypeModel.Default.DeepClone(instance, context);
		}

		public static T DeepClone<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T instance, object userState = null)
		{
			return RuntimeTypeModel.Default.DeepClone(instance, userState);
		}

		public static MeasureState<T> Measure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value, object userState = null, long abortAfter = -1L)
		{
			return RuntimeTypeModel.Default.Measure(value, userState, abortAfter);
		}

		public static T Merge<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, T instance)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, RuntimeTypeModel.Default, null, -1L);
			return state.DeserializeRootImpl(instance);
		}

		public static TTo ChangeType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TFrom, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TTo>(TFrom instance)
		{
			using MemoryStream memoryStream = new MemoryStream();
			Serialize(memoryStream, instance);
			memoryStream.Position = 0L;
			return Deserialize<TTo>(memoryStream);
		}

		public static void Merge<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(XmlReader reader, T instance) where T : IXmlSerializable
		{
			if (reader == null)
			{
				throw new ArgumentNullException("reader");
			}
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			byte[] buffer = new byte[4096];
			using MemoryStream memoryStream = new MemoryStream();
			int depth = reader.Depth;
			while (reader.Read() && reader.Depth > depth)
			{
				if (reader.NodeType == XmlNodeType.Text)
				{
					int count;
					while ((count = reader.ReadContentAsBase64(buffer, 0, 4096)) > 0)
					{
						memoryStream.Write(buffer, 0, count);
					}
					if (reader.Depth <= depth)
					{
						break;
					}
				}
			}
			memoryStream.Position = 0L;
			Merge(memoryStream, instance);
		}

		public static void Merge<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializationInfo info, T instance) where T : class, ISerializable
		{
			Merge(info, new StreamingContext(StreamingContextStates.Persistence), instance);
		}

		public static void Merge<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializationInfo info, StreamingContext context, T instance) where T : class, ISerializable
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if (instance.GetType() != typeof(T))
			{
				throw new ArgumentException("Incorrect type", "instance");
			}
			byte[] buffer = (byte[])info.GetValue("proto", typeof(byte[]));
			using MemoryStream source = new MemoryStream(buffer);
			T val = RuntimeTypeModel.Default.Deserialize(source, instance, context.Context);
			if (val != instance)
			{
				throw new ProtoException("Deserialization changed the instance; cannot succeed.");
			}
		}

		public static void PrepareSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			RuntimeTypeModel.Default[typeof(T)].CompileInPlace();
		}

		public static IFormatter CreateFormatter<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return RuntimeTypeModel.Default.CreateFormatter(typeof(T));
		}

		public static IEnumerable<T> DeserializeItems<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, PrefixStyle style, int fieldNumber)
		{
			return RuntimeTypeModel.Default.DeserializeItems<T>(source, style, fieldNumber);
		}

		public static T DeserializeWithLengthPrefix<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, PrefixStyle style)
		{
			return DeserializeWithLengthPrefix<T>(source, style, 0);
		}

		public static T DeserializeWithLengthPrefix<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, PrefixStyle style, int fieldNumber)
		{
			return (T)RuntimeTypeModel.Default.DeserializeWithLengthPrefix(source, null, typeof(T), style, fieldNumber);
		}

		public static T MergeWithLengthPrefix<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, T instance, PrefixStyle style)
		{
			return (T)RuntimeTypeModel.Default.DeserializeWithLengthPrefix(source, instance, typeof(T), style, 0);
		}

		public static bool TryReadLengthPrefix(Stream source, PrefixStyle style, out int length)
		{
			length = ProtoReader.ReadLengthPrefix(source, expectHeader: false, style, out var _, out var bytesRead);
			return bytesRead > 0;
		}

		public static bool TryReadLengthPrefix(byte[] buffer, int index, int count, PrefixStyle style, out int length)
		{
			using Stream source = new MemoryStream(buffer, index, count);
			return TryReadLengthPrefix(source, style, out length);
		}

		[Browsable(false)]
		[Obsolete("This API is no longer required and may be removed in a future release")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public static void FlushPool()
		{
		}

		public static T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, RuntimeTypeModel.Default, null, -1L);
			return state.DeserializeRootImpl<T>();
		}

		public static T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, T value, SerializationContext context, long length = -1L)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, RuntimeTypeModel.Default, context, length);
			return state.DeserializeRootImpl(value);
		}

		public static T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, T value = default(T), object userState = null, long length = -1L)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, RuntimeTypeModel.Default, userState, length);
			return state.DeserializeRootImpl(value);
		}

		public static object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, Stream source)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, RuntimeTypeModel.Default, null, -1L);
			return state.DeserializeRootFallback(null, type);
		}

		public static T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ReadOnlyMemory<byte> source, T value = default(T), object userState = null)
		{
			return RuntimeTypeModel.Default.Deserialize(source, value, userState);
		}

		public static T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ReadOnlySequence<byte> source, T value = default(T), object userState = null)
		{
			return RuntimeTypeModel.Default.Deserialize(source, value, userState);
		}

		public static T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ReadOnlySpan<byte> source, T value = default(T), object userState = null)
		{
			return RuntimeTypeModel.Default.Deserialize(source, value, userState);
		}

		public static void Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream destination, T instance)
		{
			Serialize(destination, instance, null);
		}

		public static void Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream destination, T instance, object userState)
		{
			ProtoWriter.State state = ProtoWriter.State.Create(destination, RuntimeTypeModel.Default, userState);
			try
			{
				TypeModel.SerializeImpl(ref state, instance);
			}
			finally
			{
				state.Dispose();
			}
		}

		public static void Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(IBufferWriter<byte> destination, T instance, object userState = null)
		{
			ProtoWriter.State state = ProtoWriter.State.Create(destination, RuntimeTypeModel.Default, userState);
			try
			{
				TypeModel.SerializeImpl(ref state, instance);
			}
			finally
			{
				state.Dispose();
			}
		}

		public static void Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializationInfo info, T instance) where T : class, ISerializable
		{
			Serialize(info, new StreamingContext(StreamingContextStates.Persistence), instance);
		}

		public static void Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializationInfo info, StreamingContext context, T instance) where T : class, ISerializable
		{
			if (info == null)
			{
				throw new ArgumentNullException("info");
			}
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			if (instance.GetType() != typeof(T))
			{
				throw new ArgumentException("Incorrect type", "instance");
			}
			using MemoryStream memoryStream = new MemoryStream();
			RuntimeTypeModel.Default.Serialize(memoryStream, instance, context.Context);
			info.AddValue("proto", memoryStream.ToArray());
		}

		public static void Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(XmlWriter writer, T instance) where T : IXmlSerializable
		{
			if (writer == null)
			{
				throw new ArgumentNullException("writer");
			}
			if (instance == null)
			{
				throw new ArgumentNullException("instance");
			}
			using MemoryStream memoryStream = new MemoryStream();
			Serialize(memoryStream, instance);
			Helpers.GetBuffer(memoryStream, out var segment);
			writer.WriteBase64(segment.Array, segment.Offset, segment.Count);
		}

		public static void SerializeWithLengthPrefix<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream destination, T instance, PrefixStyle style)
		{
			SerializeWithLengthPrefix(destination, instance, style, 0);
		}

		public static void SerializeWithLengthPrefix<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream destination, T instance, PrefixStyle style, int fieldNumber)
		{
			RuntimeTypeModel.Default.SerializeWithLengthPrefix(destination, instance, typeof(T), style, fieldNumber);
		}
	}
}
namespace ProtoBuf.Serializers
{
	internal static class EnumSerializers
	{
		internal static object GetSerializer(Type type)
		{
			MemberInfo underlyingProvider = RuntimeTypeModel.GetUnderlyingProvider(GetProvider(type), type);
			if (!(underlyingProvider is FieldInfo fieldInfo))
			{
				if (underlyingProvider is MethodInfo methodInfo)
				{
					return methodInfo.Invoke(null, null);
				}
				return null;
			}
			return fieldInfo.GetValue(null);
		}

		internal static MemberInfo GetProvider(Type type)
		{
			if ((object)type == null)
			{
				return null;
			}
			type = Nullable.GetUnderlyingType(type) ?? type;
			if (!type.IsEnum)
			{
				return null;
			}
			string text = Type.GetTypeCode(type) switch
			{
				TypeCode.SByte => "CreateSByte", 
				TypeCode.Int16 => "CreateInt16", 
				TypeCode.Int32 => "CreateInt32", 
				TypeCode.Int64 => "CreateInt64", 
				TypeCode.Byte => "CreateByte", 
				TypeCode.UInt16 => "CreateUInt16", 
				TypeCode.UInt32 => "CreateUInt32", 
				TypeCode.UInt64 => "CreateUInt64", 
				_ => null, 
			};
			if (text == null)
			{
				return null;
			}
			return typeof(EnumSerializer).GetMethod(text, BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(type);
		}
	}
	internal static class RepeatedSerializers
	{
		[StructLayout(LayoutKind.Auto)]
		[<da4ae7fc-788b-41bf-a5c9-fb56955443e9>IsReadOnly]
		private struct MethodTuple
		{
			public string Name => Method.Name;

			private MethodInfo Method { get; }

			public int GenericArgCount { get; }

			public MethodInfo Construct(Type[] targs)
			{
				if (GenericArgCount != 0)
				{
					return Method.MakeGenericMethod(targs);
				}
				return Method;
			}

			public MethodTuple(MethodInfo method)
			{
				Method = method;
				GenericArgCount = (method.IsGenericMethodDefinition ? method.GetGenericArguments().Length : 0);
			}
		}

		private sealed class Registration
		{
			public bool ExactOnly { get; }

			public int Priority { get; }

			private Func<Type, Type, Type[], MemberInfo> Implementation { get; }

			public MemberInfo Resolve(Type root, Type current)
			{
				Type[] arg = (current.IsGenericType ? current.GetGenericArguments() : ((!current.IsArray) ? Type.EmptyTypes : new Type[1] { current.GetElementType() }));
				return Implementation?.Invoke(root, current, arg);
			}

			public Registration(int priority, Func<Type, Type, Type[], MemberInfo> implementation, bool exactOnly)
			{
				Priority = priority;
				Implementation = implementation;
				ExactOnly = exactOnly;
			}
		}

		private static readonly Hashtable s_providers;

		private static readonly Hashtable s_methodsPerDeclaringType;

		private static readonly Hashtable s_knownTypes;

		private static readonly Registration s_Array;

		private static readonly Type[] NotSupportedFlavors;

		private static readonly MethodInfo s_NestedNotSupported;

		private static readonly MethodInfo s_GeneralNotSupported;

		internal static MemberInfo Resolve(Type declaringType, string methodName, Type[] targs)
		{
			if (targs == null)
			{
				targs = Type.EmptyTypes;
			}
			MethodTuple[] array = (MethodTuple[])s_methodsPerDeclaringType[declaringType];
			if (array == null)
			{
				MethodInfo[] methods = declaringType.GetMethods(BindingFlags.Static | BindingFlags.Public);
				array = Array.ConvertAll(methods, (MethodInfo m) => new MethodTuple(m));
				lock (s_methodsPerDeclaringType)
				{
					s_methodsPerDeclaringType[declaringType] = array;
				}
			}
			MethodTuple[] array2 = array;
			for (int i = 0; i < array2.Length; i++)
			{
				MethodTuple methodTuple = array2[i];
				if (methodTuple.Name == methodName && targs.Length == methodTuple.GenericArgCount)
				{
					return methodTuple.Construct(targs);
				}
			}
			return null;
		}

		static RepeatedSerializers()
		{
			s_methodsPerDeclaringType = new Hashtable();
			s_knownTypes = new Hashtable();
			s_Array = new Registration(0, (Type root, Type current, Type[] targs) => (!(root == current)) ? null : Resolve(typeof(RepeatedSerializer), "CreateVector", targs), exactOnly: true);
			NotSupportedFlavors = new Type[7]
			{
				typeof(Span<>),
				typeof(ReadOnlySpan<>),
				typeof(ReadOnlySequence<>),
				typeof(ReadOnlyMemory<>),
				typeof(Memory<>),
				typeof(ArraySegment<>),
				typeof(IMemoryOwner<>)
			};
			s_NestedNotSupported = typeof(RepeatedSerializer).GetMethod("CreateNestedDataNotSupported");
			s_GeneralNotSupported = typeof(RepeatedSerializer).GetMethod("CreateNotSupported");
			s_providers = new Hashtable();
			Add(typeof(List<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateList", (root == current) ? targs : new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
			Add(typeof(ImmutableArray<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableArray", targs));
			Add(typeof(ImmutableDictionary<, >), (Type root, Type current, Type[] targs) => Resolve(typeof(MapSerializer), "CreateImmutableDictionary", targs));
			Add(typeof(ImmutableSortedDictionary<, >), (Type root, Type current, Type[] targs) => Resolve(typeof(MapSerializer), "CreateImmutableSortedDictionary", targs));
			Add(typeof(IImmutableDictionary<, >), (Type root, Type current, Type[] targs) => Resolve(typeof(MapSerializer), "CreateIImmutableDictionary", targs));
			Add(typeof(ImmutableList<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableList", targs));
			Add(typeof(IImmutableList<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableIList", targs));
			Add(typeof(ImmutableHashSet<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableHashSet", targs));
			Add(typeof(ImmutableSortedSet<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableSortedSet", targs));
			Add(typeof(IImmutableSet<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableISet", targs));
			Add(typeof(ImmutableQueue<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableQueue", targs));
			Add(typeof(IImmutableQueue<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableIQueue", targs));
			Add(typeof(ImmutableStack<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableStack", targs));
			Add(typeof(IImmutableStack<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateImmutableIStack", targs));
			Add(typeof(ConcurrentDictionary<, >), (Type root, Type current, Type[] targs) => Resolve(typeof(MapSerializer), "CreateConcurrentDictionary", new Type[3]
			{
				root,
				targs[0],
				targs[1]
			}), exactOnly: false);
			Add(typeof(ConcurrentBag<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateConcurrentBag", new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
			Add(typeof(ConcurrentQueue<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateConcurrentQueue", new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
			Add(typeof(ConcurrentStack<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateConcurrentStack", new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
			Add(typeof(IProducerConsumerCollection<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateIProducerConsumerCollection", new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
			Add(typeof(Dictionary<, >), (Type root, Type current, Type[] targs) => Resolve(typeof(MapSerializer), "CreateDictionary", (root == current) ? targs : new Type[3]
			{
				root,
				targs[0],
				targs[1]
			}), exactOnly: false);
			Add(typeof(IDictionary<, >), (Type root, Type current, Type[] targs) => Resolve(typeof(MapSerializer), "CreateDictionary", new Type[3]
			{
				root,
				targs[0],
				targs[1]
			}), exactOnly: false);
			Add(typeof(IReadOnlyDictionary<, >), (Type root, Type current, Type[] targs) => Resolve(typeof(MapSerializer), "CreateIReadOnlyDictionary", targs));
			Add(typeof(Queue<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateQueue", new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
			Add(typeof(Stack<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateStack", new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
			Add(typeof(IEnumerable<>), (Type root, Type current, Type[] targs) => Resolve(typeof(RepeatedSerializer), "CreateEnumerable", new Type[2]
			{
				root,
				targs[0]
			}), exactOnly: false);
		}

		public static void Add(Type type, Func<Type, Type, Type[], MemberInfo> implementation, bool exactOnly = true, Hashtable externalProviders = null)
		{
			Hashtable hashtable = ((externalProviders == null) ? s_providers : externalProviders);
			if ((object)type == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("type");
			}
			lock (hashtable)
			{
				Registration value = new Registration(s_providers.Count * ((externalProviders == null) ? 1 : (-1)) + 1, implementation, exactOnly);
				hashtable.Add(type, value);
			}
			lock (s_knownTypes)
			{
				s_knownTypes.Clear();
			}
		}

		internal static RepeatedSerializerStub TryGetRepeatedProvider(Type type, Hashtable externalProvders = null)
		{
			if ((object)type == null || type == typeof(string))
			{
				return null;
			}
			RepeatedSerializerStub repeatedSerializerStub = (RepeatedSerializerStub)s_knownTypes[type];
			if (repeatedSerializerStub == null)
			{
				Type genericTypeDefinition;
				if (!TypeHelper.IsBytesLike(type) && type.IsGenericType && Array.IndexOf(NotSupportedFlavors, genericTypeDefinition = type.GetGenericTypeDefinition()) >= 0)
				{
					if (genericTypeDefinition == typeof(Span<>) || genericTypeDefinition == typeof(ReadOnlySpan<>))
					{
						throw new NotSupportedException("Serialization cannot work with [ReadOnly]Span<T>; [ReadOnly]Memory<T> may be enabled later");
					}
					repeatedSerializerStub = NotSupported(s_GeneralNotSupported, type, type.GetGenericArguments()[0]);
				}
				else
				{
					MemberInfo providerForType = GetProviderForType(type, externalProvders);
					if ((object)providerForType == null)
					{
						repeatedSerializerStub = ((!type.IsArray || !(type != typeof(byte[]))) ? RepeatedSerializerStub.Empty : NotSupported(s_GeneralNotSupported, type, type.GetElementType()));
					}
					else
					{
						repeatedSerializerStub = RepeatedSerializerStub.Create(type, providerForType);
						if (TestIfNestedNotSupported(repeatedSerializerStub))
						{
							repeatedSerializerStub = NotSupported(s_NestedNotSupported, repeatedSerializerStub.ForType, repeatedSerializerStub.ItemType);
						}
					}
				}
				lock (s_knownTypes)
				{
					s_knownTypes[type] = repeatedSerializerStub;
				}
			}
			if (!repeatedSerializerStub.IsEmpty)
			{
				return repeatedSerializerStub;
			}
			return null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static RepeatedSerializerStub NotSupported(MethodInfo kind, Type collectionType, Type itemType)
		{
			return RepeatedSerializerStub.Create(collectionType, kind.MakeGenericMethod(collectionType, itemType));
		}

		private static bool TestIfNestedNotSupported(RepeatedSerializerStub repeated)
		{
			if ((object)repeated?.ItemType == null)
			{
				return false;
			}
			if (!repeated.IsMap && (repeated.ItemType == repeated.ForType || TryGetRepeatedProvider(repeated.ItemType) != null))
			{
				return true;
			}
			return false;
		}

		private static MemberInfo GetProviderForType(Type type, Hashtable externalProviders)
		{
			if ((object)type == null)
			{
				return null;
			}
			if (TypeHelper.IsBytesLike(type))
			{
				return null;
			}
			if (type.IsArray)
			{
				Type type2 = type.GetElementType().MakeArrayType();
				if (!(type2 == type))
				{
					return null;
				}
				return s_Array.Resolve(type, type2);
			}
			MemberInfo bestMatch = null;
			int bestMatchPriority = int.MaxValue;
			bool bestIsAmbiguous = false;
			Type type3 = type;
			if (externalProviders != null)
			{
				while ((object)type3 != null && type3 != typeof(object))
				{
					if (TryGetExternalProvider(type, type3, bestMatchPriority, out var member2, out var priority2, externalProviders))
					{
						Consider(member2, priority2);
					}
					type3 = type3.BaseType;
				}
				Type[] interfaces = type.GetInterfaces();
				foreach (Type current in interfaces)
				{
					if (TryGetExternalProvider(type, current, bestMatchPriority, out var member3, out var priority3, externalProviders))
					{
						Consider(member3, priority3);
					}
				}
			}
			type3 = type;
			while ((object)type3 != null && type3 != typeof(object))
			{
				if (TryGetProvider(type, type3, bestMatchPriority, out var member4, out var priority4))
				{
					Consider(member4, priority4);
				}
				type3 = type3.BaseType;
			}
			Type[] interfaces2 = type.GetInterfaces();
			foreach (Type current2 in interfaces2)
			{
				if (TryGetProvider(type, current2, bestMatchPriority, out var member5, out var priority5))
				{
					Consider(member5, priority5);
				}
			}
			if (!bestIsAmbiguous)
			{
				return bestMatch;
			}
			return null;
			void Consider(MemberInfo member, int priority)
			{
				if (priority < bestMatchPriority)
				{
					bestMatch = member;
					bestMatchPriority = priority;
					bestIsAmbiguous = false;
				}
				else if (priority == bestMatchPriority && !object.Equals(bestMatch, member))
				{
					bestIsAmbiguous = true;
				}
			}
		}

		private static bool TryGetProvider(Type root, Type current, int bestMatchPriority, out MemberInfo member, out int priority)
		{
			Registration registration = (Registration)s_providers[current];
			if (registration == null && current.IsGenericType)
			{
				registration = (Registration)s_providers[current.GetGenericTypeDefinition()];
			}
			if (registration == null || registration.Priority > bestMatchPriority || (registration.ExactOnly && root != current))
			{
				member = null;
				priority = 0;
				return false;
			}
			member = registration.Resolve(root, current);
			priority = registration.Priority;
			return true;
		}

		private static bool TryGetExternalProvider(Type root, Type current, int bestMatchPriority, out MemberInfo member, out int priority, Hashtable externalProviders)
		{
			Registration registration = (Registration)externalProviders[current];
			if (registration == null && current.IsGenericType)
			{
				registration = (Registration)externalProviders[current.GetGenericTypeDefinition()];
			}
			if (registration == null || registration.Priority > bestMatchPriority || (registration.ExactOnly && root != current))
			{
				member = null;
				priority = 0;
				return false;
			}
			member = registration.Resolve(root, current);
			priority = registration.Priority;
			return true;
		}
	}
	internal sealed class RepeatedSerializerStub
	{
		internal static readonly RepeatedSerializerStub Empty = new RepeatedSerializerStub(null, null);

		private object _serializer;

		public MemberInfo Provider { get; }

		public bool IsMap { get; }

		public bool IsEmpty => (object)Provider == null;

		public object Serializer => _serializer ?? CreateSerializer();

		public Type ForType { get; }

		public Type ItemType { get; }

		internal bool IsValidProtobufMap(RuntimeTypeModel model, CompatibilityLevel compatibilityLevel, DataFormat dataFormat)
		{
			if (!IsMap)
			{
				return false;
			}
			ResolveMapTypes(out var keyType, out var valueType);
			if (!IsValidKey(keyType, compatibilityLevel, dataFormat))
			{
				return false;
			}
			RepeatedSerializerStub repeatedSerializerStub = ((model == null) ? RepeatedSerializers.TryGetRepeatedProvider(valueType) : model.TryGetRepeatedProvider(valueType));
			if (repeatedSerializerStub != null)
			{
				return false;
			}
			return true;
			static bool IsValidKey(Type type, CompatibilityLevel compatibilityLevel, DataFormat dataFormat)
			{
				if ((object)type == null)
				{
					return false;
				}
				if (type.IsEnum)
				{
					return true;
				}
				if (type == typeof(string))
				{
					return true;
				}
				if (!type.IsValueType)
				{
					return false;
				}
				if ((object)Nullable.GetUnderlyingType(type) != null)
				{
					return false;
				}
				TypeCode typeCode = Type.GetTypeCode(type);
				if ((uint)(typeCode - 5) <= 7u)
				{
					return true;
				}
				if (compatibilityLevel >= CompatibilityLevel.Level300 && type == typeof(Guid) && dataFormat != DataFormat.FixedSize)
				{
					return true;
				}
				return false;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private object CreateSerializer()
		{
			try
			{
				MemberInfo underlyingProvider = RuntimeTypeModel.GetUnderlyingProvider(Provider, ForType);
				object serializer;
				if (!(underlyingProvider is FieldInfo fieldInfo))
				{
					if (!(underlyingProvider is MethodInfo methodInfo) || !methodInfo.IsStatic)
					{
						goto IL_004d;
					}
					serializer = methodInfo.Invoke(null, null);
				}
				else
				{
					if (!fieldInfo.IsStatic)
					{
						goto IL_004d;
					}
					serializer = fieldInfo.GetValue(null);
				}
				goto IL_004f;
				IL_004d:
				serializer = null;
				goto IL_004f;
				IL_004f:
				_serializer = serializer;
				return _serializer;
			}
			catch (TargetInvocationException ex) when (ex.InnerException != null)
			{
				throw ex.InnerException;
			}
		}

		internal void EmitProvider(CompilerContext ctx)
		{
			EmitProvider(ctx.IL);
		}

		private void EmitProvider(ILGenerator il)
		{
			MemberInfo underlyingProvider = RuntimeTypeModel.GetUnderlyingProvider(Provider, ForType);
			RuntimeTypeModel.EmitProvider(underlyingProvider, il);
		}

		public static RepeatedSerializerStub Create(Type forType, MemberInfo provider)
		{
			if ((object)provider != null)
			{
				return new RepeatedSerializerStub(forType, provider);
			}
			return Empty;
		}

		private RepeatedSerializerStub(Type forType, MemberInfo provider)
		{
			ForType = forType;
			Provider = provider;
			IsMap = CheckIsMap(provider, out var itemType);
			ItemType = itemType;
		}

		private static bool CheckIsMap(MemberInfo provider, out Type itemType)
		{
			Type type2 = ((provider is MethodInfo methodInfo) ? methodInfo.ReturnType : ((provider is FieldInfo fieldInfo) ? fieldInfo.FieldType : ((provider is PropertyInfo propertyInfo) ? propertyInfo.PropertyType : ((!(provider is Type type)) ? null : type))));
			Type type3 = type2;
			while ((object)type3 != null && type3 != typeof(object))
			{
				if (type3.IsGenericType)
				{
					Type genericTypeDefinition = type3.GetGenericTypeDefinition();
					if (genericTypeDefinition == typeof(MapSerializer<, , >))
					{
						Type[] genericArguments = type3.GetGenericArguments();
						itemType = typeof(KeyValuePair<, >).MakeGenericType(genericArguments[1], genericArguments[2]);
						return true;
					}
					if (genericTypeDefinition == typeof(RepeatedSerializer<, >))
					{
						Type[] genericArguments2 = type3.GetGenericArguments();
						itemType = genericArguments2[1];
						return false;
					}
				}
				type3 = type3.BaseType;
			}
			itemType = null;
			return false;
		}

		internal void ResolveMapTypes(out Type keyType, out Type valueType)
		{
			keyType = (valueType = null);
			if (IsMap)
			{
				Type[] genericArguments = ItemType.GetGenericArguments();
				keyType = genericArguments[0];
				valueType = genericArguments[1];
			}
		}
	}
}
namespace ProtoBuf.Meta
{
	internal abstract class AttributeMap
	{
		private sealed class ReflectionAttributeMap : AttributeMap
		{
			private readonly Attribute attribute;

			public override object Target => attribute;

			public override Type AttributeType => attribute.GetType();

			public ReflectionAttributeMap(Attribute attribute)
			{
				this.attribute = attribute;
			}

			public override bool TryGet(string key, bool publicOnly, out object value)
			{
				MemberInfo[] instanceFieldsAndProperties = Helpers.GetInstanceFieldsAndProperties(attribute.GetType(), publicOnly);
				MemberInfo[] array = instanceFieldsAndProperties;
				foreach (MemberInfo memberInfo in array)
				{
					if (string.Equals(memberInfo.Name, key, StringComparison.OrdinalIgnoreCase))
					{
						if (memberInfo is PropertyInfo propertyInfo)
						{
							value = propertyInfo.GetValue(attribute, null);
							return true;
						}
						if (memberInfo is FieldInfo fieldInfo)
						{
							value = fieldInfo.GetValue(attribute);
							return true;
						}
						throw new NotSupportedException(memberInfo.GetType().Name);
					}
				}
				value = null;
				return false;
			}
		}

		public abstract Type AttributeType { get; }

		public abstract object Target { get; }

		[Obsolete("Please use AttributeType instead")]
		public new Type GetType()
		{
			return AttributeType;
		}

		public override string ToString()
		{
			return AttributeType?.FullName ?? "";
		}

		public abstract bool TryGet(string key, bool publicOnly, out object value);

		public bool TryGet(string key, out object value)
		{
			return TryGet(key, publicOnly: true, out value);
		}

		public static AttributeMap[] Create(Type type, bool inherit)
		{
			object[] customAttributes = type.GetCustomAttributes(inherit);
			AttributeMap[] array = new AttributeMap[customAttributes.Length];
			for (int i = 0; i < customAttributes.Length; i++)
			{
				array[i] = new ReflectionAttributeMap((Attribute)customAttributes[i]);
			}
			return array;
		}

		public static AttributeMap[] Create(MemberInfo member, bool inherit)
		{
			object[] customAttributes = member.GetCustomAttributes(inherit);
			AttributeMap[] array = new AttributeMap[customAttributes.Length];
			for (int i = 0; i < customAttributes.Length; i++)
			{
				array[i] = new ReflectionAttributeMap((Attribute)customAttributes[i]);
			}
			return array;
		}

		public static AttributeMap[] Create(Assembly assembly)
		{
			object[] customAttributes = assembly.GetCustomAttributes(inherit: false);
			AttributeMap[] array = new AttributeMap[customAttributes.Length];
			for (int i = 0; i < customAttributes.Length; i++)
			{
				array[i] = new ReflectionAttributeMap((Attribute)customAttributes[i]);
			}
			return array;
		}
	}
	internal sealed class AutoCompileTypeModel : TypeModel
	{
		private static readonly Hashtable s_assemblyModels = new Hashtable();

		public static TypeModel Instance { get; } = new AutoCompileTypeModel();


		public new static TypeModel CreateForAssembly<T>()
		{
			return CreateForAssembly(typeof(T).Assembly, null);
		}

		public new static TypeModel CreateForAssembly(Type type)
		{
			if ((object)type == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("type");
			}
			return CreateForAssembly(type.Assembly, null);
		}

		public new static TypeModel CreateForAssembly(Assembly assembly)
		{
			return CreateForAssembly(assembly, null);
		}

		public static TypeModel CreateForAssembly(Assembly assembly, RuntimeTypeModel.CompilerOptions options)
		{
			if ((object)assembly == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("assembly");
			}
			if (options == null)
			{
				TypeModel typeModel = (TypeModel)s_assemblyModels[assembly];
				if (typeModel != null)
				{
					return typeModel;
				}
			}
			return CreateForAssemblyImpl(assembly, options);
		}

		private AutoCompileTypeModel()
		{
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static TypeModel ForAssembly(Type type)
		{
			if ((object)type != null)
			{
				return CreateForAssembly(type.Assembly, null);
			}
			return NullModel.Singleton;
		}

		public override string GetSchema(SchemaGenerationOptions options)
		{
			return ForAssembly(options.HasTypes ? options.Types.First() : null).GetSchema(options);
		}

		protected override ISerializer<T> GetSerializer<T>()
		{
			return ForAssembly(typeof(T)).GetSerializerCore<T>(CompatibilityLevel.NotSpecified);
		}

		internal override bool IsKnownType<T>(CompatibilityLevel ambient)
		{
			return ForAssembly(typeof(T)).IsKnownType<T>(ambient);
		}

		private static TypeModel CreateForAssemblyImpl(Assembly assembly, RuntimeTypeModel.CompilerOptions options)
		{
			if ((object)assembly == null)
			{
				throw new ArgumentNullException("assembly");
			}
			lock (assembly)
			{
				TypeModel typeModel = (TypeModel)s_assemblyModels[assembly];
				if (typeModel != null)
				{
					return typeModel;
				}
				RuntimeTypeModel runtimeTypeModel = null;
				Type[] types = assembly.GetTypes();
				foreach (Type type in types)
				{
					if (!type.IsGenericTypeDefinition && RuntimeTypeModel.IsFullyPublic(type) && type.IsDefined(typeof(ProtoContractAttribute), inherit: true) && (options == null || options.OnIncludeType(type)))
					{
						(runtimeTypeModel ?? (runtimeTypeModel = RuntimeTypeModel.Create("CreateForAssemblyImpl"))).Add(type, applyDefaultBehaviour: true);
					}
				}
				if (runtimeTypeModel == null)
				{
					throw new InvalidOperationException("No types marked [ProtoContract] found in assembly '" + assembly.GetName().Name + "'");
				}
				TypeModel typeModel2 = runtimeTypeModel.Compile(options);
				s_assemblyModels[assembly] = typeModel2;
				return typeModel2;
			}
		}
	}
	internal class CallbackSet
	{
		private readonly MetaType metaType;

		private MethodInfo beforeSerialize;

		private MethodInfo afterSerialize;

		private MethodInfo beforeDeserialize;

		private MethodInfo afterDeserialize;

		internal MethodInfo this[TypeModel.CallbackType callbackType] => callbackType switch
		{
			TypeModel.CallbackType.BeforeSerialize => beforeSerialize, 
			TypeModel.CallbackType.AfterSerialize => afterSerialize, 
			TypeModel.CallbackType.BeforeDeserialize => beforeDeserialize, 
			TypeModel.CallbackType.AfterDeserialize => afterDeserialize, 
			_ => throw new ArgumentException("Callback type not supported: " + callbackType, "callbackType"), 
		};

		public MethodInfo BeforeSerialize
		{
			get
			{
				return beforeSerialize;
			}
			set
			{
				beforeSerialize = SanityCheckCallback(value);
			}
		}

		public MethodInfo BeforeDeserialize
		{
			get
			{
				return beforeDeserialize;
			}
			set
			{
				beforeDeserialize = SanityCheckCallback(value);
			}
		}

		public MethodInfo AfterSerialize
		{
			get
			{
				return afterSerialize;
			}
			set
			{
				afterSerialize = SanityCheckCallback(value);
			}
		}

		public MethodInfo AfterDeserialize
		{
			get
			{
				return afterDeserialize;
			}
			set
			{
				afterDeserialize = SanityCheckCallback(value);
			}
		}

		public bool NonTrivial
		{
			get
			{
				if ((object)beforeSerialize == null && (object)beforeDeserialize == null && (object)afterSerialize == null)
				{
					return (object)afterDeserialize != null;
				}
				return true;
			}
		}

		internal CallbackSet(MetaType metaType)
		{
			this.metaType = metaType ?? throw new ArgumentNullException("metaType");
		}

		internal static bool CheckCallbackParameters(MethodInfo method)
		{
			ParameterInfo[] parameters = method.GetParameters();
			for (int i = 0; i < parameters.Length; i++)
			{
				Type parameterType = parameters[i].ParameterType;
				if (!(parameterType == typeof(SerializationContext)) && !(parameterType == typeof(Type)) && !(parameterType == typeof(StreamingContext)))
				{
					return false;
				}
			}
			return true;
		}

		private MethodInfo SanityCheckCallback(MethodInfo callback)
		{
			metaType.ThrowIfFrozen();
			if ((object)callback == null)
			{
				return callback;
			}
			if (callback.IsStatic)
			{
				throw new ArgumentException("Callbacks cannot be static", "callback");
			}
			if (callback.ReturnType != typeof(void) || !CheckCallbackParameters(callback))
			{
				throw CreateInvalidCallbackSignature(callback);
			}
			return callback;
		}

		internal static Exception CreateInvalidCallbackSignature(MethodInfo method)
		{
			return new NotSupportedException("Invalid callback signature in " + method.DeclaringType.FullName + "." + method.Name);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	[<da4ae7fc-788b-41bf-a5c9-fb56955443e9>IsReadOnly]
	internal struct EnumMember : IEquatable<EnumMember>
	{
		public string Name { get; }

		public object Value { get; }

		internal bool HasValue
		{
			get
			{
				if (Value != null)
				{
					return !string.IsNullOrWhiteSpace(Name);
				}
				return false;
			}
		}

		public EnumMember(object value, string name)
		{
			Name = name;
			Value = value;
		}

		internal int? TryGetInt32()
		{
			return TryGetInt32(Value);
		}

		internal static int? TryGetInt32(object value)
		{
			if (value != null)
			{
				Type type = value.GetType();
				if (type.IsEnum)
				{
					type = Enum.GetUnderlyingType(type);
				}
				switch (Type.GetTypeCode(type))
				{
				case TypeCode.SByte:
					return (sbyte)value;
				case TypeCode.Int16:
					return (short)value;
				case TypeCode.Int32:
					return (int)value;
				case TypeCode.Byte:
					return (byte)value;
				case TypeCode.UInt16:
					return (ushort)value;
				case TypeCode.UInt32:
				{
					uint num3 = (uint)value;
					if (num3 <= int.MaxValue)
					{
						return (int)num3;
					}
					break;
				}
				case TypeCode.UInt64:
				{
					ulong num2 = (ulong)value;
					if (num2 <= int.MaxValue)
					{
						return (int)num2;
					}
					break;
				}
				case TypeCode.Int64:
				{
					long num = (long)value;
					if (num >= int.MinValue && num <= int.MaxValue)
					{
						return (int)num;
					}
					break;
				}
				}
			}
			return null;
		}

		public EnumMember WithName(string name)
		{
			return new EnumMember(Value, name);
		}

		public EnumMember WithValue(object value)
		{
			return new EnumMember(value, Name);
		}

		public EnumMember Normalize(Type type)
		{
			return WithValue(Normalize(Value, type));
		}

		public bool Equals<[<3ab5f816-f121-4279-90dc-7a65a54777ac>IsUnmanaged] T>(T value) where T : struct
		{
			return object.Equals(Normalize(Value, typeof(T)), Normalize(value, typeof(T)));
		}

		public override string ToString()
		{
			return $"{Name}={Value}";
		}

		public override int GetHashCode()
		{
			return (Name?.GetHashCode() ?? 0) ^ (Value?.GetHashCode() ?? 0);
		}

		public override bool Equals(object obj)
		{
			if (obj is EnumMember other)
			{
				return Equals(other);
			}
			return false;
		}

		public bool Equals(EnumMember other)
		{
			if (string.Equals(Name, other.Name))
			{
				return object.Equals(Value, other.Value);
			}
			return false;
		}

		public static bool operator ==(EnumMember x, EnumMember y)
		{
			return x.Equals(y);
		}

		public static bool operator !=(EnumMember x, EnumMember y)
		{
			return !x.Equals(y);
		}

		private static object Normalize(object value, Type type)
		{
			return Convert.ChangeType(value, type.IsEnum ? Enum.GetUnderlyingType(type) : type);
		}

		public static EnumMember Create<[<3ab5f816-f121-4279-90dc-7a65a54777ac>IsUnmanaged] T>(T value) where T : struct
		{
			return new EnumMember(value, value.ToString()).Normalize(typeof(T));
		}

		internal void Validate()
		{
			if (string.IsNullOrWhiteSpace(Name))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("All enum declarations must have valid names");
			}
		}
	}
	internal sealed class MetaType : ISerializerProxy
	{
		internal sealed class Comparer : IComparer, IComparer<MetaType>
		{
			private readonly HashSet<Type> _callstack;

			internal Comparer(HashSet<Type> callstack)
			{
				_callstack = callstack;
			}

			public int Compare(object x, object y)
			{
				return Compare(x as MetaType, y as MetaType);
			}

			public int Compare(MetaType x, MetaType y)
			{
				if (x == y)
				{
					return 0;
				}
				if (x == null)
				{
					return -1;
				}
				if (y == null)
				{
					return 1;
				}
				return string.Compare(x.GetSchemaTypeName(_callstack), y.GetSchemaTypeName(_callstack), StringComparison.Ordinal);
			}
		}

		[Flags]
		internal enum AttributeFamily
		{
			None = 0,
			ProtoBuf = 1,
			DataContractSerializer = 2,
			XmlSerializer = 4,
			AutoTuple = 8
		}

		private enum TypeOptions : ushort
		{
			None = 0,
			Pending = 1,
			Frozen = 4,
			PrivateOnApi = 8,
			SkipConstructor = 0x10,
			AutoTuple = 0x40,
			IgnoreListHandling = 0x80,
			IsGroup = 0x100,
			IgnoreUnknownSubTypes = 0x200
		}

		private class ExtraLayerValueMembers : IEnumerable<NullWrappedValueMemberData>, IEnumerable
		{
			private readonly Dictionary<string, Type> _schemaMemberTypeMap = new Dictionary<string, Type>();

			private readonly Dictionary<string, NullWrappedValueMemberData> _wrappedSchemaMembers = new Dictionary<string, NullWrappedValueMemberData>();

			public bool IsEmpty()
			{
				return _wrappedSchemaMembers.Count == 0;
			}

			public NullWrappedValueMemberData Add(string schemaTypeName, ValueMember valueMember)
			{
				if (!_schemaMemberTypeMap.ContainsKey(schemaTypeName))
				{
					NullWrappedValueMemberData nullWrappedValueMemberData = new NullWrappedValueMemberData(valueMember, schemaTypeName);
					_schemaMemberTypeMap[schemaTypeName] = nullWrappedValueMemberData.ItemType;
					_wrappedSchemaMembers[nullWrappedValueMemberData.WrappedSchemaTypeName] = nullWrappedValueMemberData;
					return nullWrappedValueMemberData;
				}
				Type type = _schemaMemberTypeMap[schemaTypeName];
				if (type == valueMember.ItemType)
				{
					NullWrappedValueMemberData nullWrappedValueMemberData2 = new NullWrappedValueMemberData(valueMember, schemaTypeName);
					_wrappedSchemaMembers[nullWrappedValueMemberData2.WrappedSchemaTypeName] = nullWrappedValueMemberData2;
					return nullWrappedValueMemberData2;
				}
				if (string.IsNullOrEmpty(valueMember.Name) || valueMember.Member?.Name == valueMember.Name)
				{
					NullWrappedValueMemberData nullWrappedValueMemberData3 = new NullWrappedValueMemberData(valueMember, schemaTypeName, null, hasSchemaTypeNameCollision: true);
					_wrappedSchemaMembers[nullWrappedValueMemberData3.WrappedSchemaTypeName] = nullWrappedValueMemberData3;
					return nullWrappedValueMemberData3;
				}
				string name = valueMember.Name;
				if (_schemaMemberTypeMap.ContainsKey(name))
				{
					NullWrappedValueMemberData nullWrappedValueMemberData4 = new NullWrappedValueMemberData(valueMember, schemaTypeName, name, hasSchemaTypeNameCollision: true);
					_wrappedSchemaMembers[nullWrappedValueMemberData4.WrappedSchemaTypeName] = nullWrappedValueMemberData4;
					return nullWrappedValueMemberData4;
				}
				NullWrappedValueMemberData nullWrappedValueMemberData5 = new NullWrappedValueMemberData(valueMember, schemaTypeName, name);
				_schemaMemberTypeMap[name] = nullWrappedValueMemberData5.ItemType;
				_wrappedSchemaMembers[nullWrappedValueMemberData5.WrappedSchemaTypeName] = nullWrappedValueMemberData5;
				return nullWrappedValueMemberData5;
			}

			public IEnumerator<NullWrappedValueMemberData> GetEnumerator()
			{
				return _wrappedSchemaMembers.Values.GetEnumerator();
			}

			IEnumerator IEnumerable.GetEnumerator()
			{
				return GetEnumerator();
			}
		}

		private MetaType baseType;

		private CompatibilityLevel _compatibilityLevel;

		private List<SubType> _subTypes;

		private CallbackSet callbacks;

		private string name;

		private string origin;

		private MethodInfo factory;

		private readonly RuntimeTypeModel model;

		private IProtoTypeSerializer _serializer;

		private Type constructType;

		internal Type surrogateType;

		internal DataFormat surrogateDataFormat;

		private MethodInfo underlyingToSurrogate;

		private MethodInfo surrogateToUnderlying;

		private List<ValueMember> _fields;

		private List<EnumMember> _enums = new List<EnumMember>();

		private volatile TypeOptions flags;

		private Type _serializerType;

		private List<ProtoReservedAttribute> _reservations;

		IRuntimeProtoSerializerNode ISerializerProxy.Serializer => Serializer;

		public MetaType BaseType => baseType;

		internal RuntimeTypeModel Model => model;

		public CompatibilityLevel CompatibilityLevel
		{
			get
			{
				return _compatibilityLevel;
			}
			set
			{
				if (value != _compatibilityLevel)
				{
					if (HasFields)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"{CompatibilityLevel} cannot be set once fields have been defined");
					}
					CompatibilityLevelAttribute.AssertValid(value);
					_compatibilityLevel = value;
				}
			}
		}

		public bool IncludeSerializerMethod
		{
			get
			{
				return !HasFlag(TypeOptions.PrivateOnApi);
			}
			set
			{
				SetFlag(TypeOptions.PrivateOnApi, !value, throwIfFrozen: true);
			}
		}

		public bool AsReferenceDefault
		{
			get
			{
				return false;
			}
			[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", true)]
			set
			{
				if (value != AsReferenceDefault)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
				}
			}
		}

		public bool HasCallbacks
		{
			get
			{
				if (callbacks != null)
				{
					return callbacks.NonTrivial;
				}
				return false;
			}
		}

		public bool HasSubtypes
		{
			get
			{
				if (_subTypes != null)
				{
					return _subTypes.Count != 0;
				}
				return false;
			}
		}

		public CallbackSet Callbacks => callbacks ?? (callbacks = new CallbackSet(this));

		private bool IsValueType => Type.IsValueType;

		public string Name
		{
			get
			{
				return name;
			}
			set
			{
				ThrowIfFrozen();
				name = value;
			}
		}

		public string Origin
		{
			get
			{
				return origin;
			}
			set
			{
				ThrowIfFrozen();
				origin = value;
			}
		}

		public Type Type { get; }

		internal IProtoTypeSerializer Serializer
		{
			get
			{
				if (_serializer == null)
				{
					int opaqueToken = 0;
					try
					{
						model.TakeLock(ref opaqueToken);
						if (_serializer == null)
						{
							SetFlag(TypeOptions.Frozen, value: true, throwIfFrozen: false);
							_serializer = BuildSerializer();
							if (model.AutoCompile)
							{
								CompileInPlace();
							}
						}
					}
					finally
					{
						model.ReleaseLock(opaqueToken);
					}
				}
				return _serializer;
			}
		}

		public bool UseConstructor
		{
			get
			{
				return !HasFlag(TypeOptions.SkipConstructor);
			}
			set
			{
				SetFlag(TypeOptions.SkipConstructor, !value, throwIfFrozen: true);
			}
		}

		public Type ConstructType
		{
			get
			{
				return constructType;
			}
			set
			{
				ThrowIfFrozen();
				constructType = value;
			}
		}

		internal bool HasSurrogate => (object)surrogateType != null;

		public ValueMember this[int fieldNumber]
		{
			get
			{
				if (HasFields)
				{
					foreach (ValueMember field in Fields)
					{
						if (field.FieldNumber == fieldNumber)
						{
							return field;
						}
					}
				}
				return null;
			}
		}

		public ValueMember this[MemberInfo member]
		{
			get
			{
				if ((object)member == null || !HasFields)
				{
					return null;
				}
				foreach (ValueMember field in Fields)
				{
					if (field.Member == member || field.BackingMember == member)
					{
						return field;
					}
				}
				return null;
			}
		}

		internal bool HasFields
		{
			get
			{
				if (_fields != null)
				{
					return _fields.Count != 0;
				}
				return false;
			}
		}

		internal List<ValueMember> Fields => _fields ?? (_fields = new List<ValueMember>());

		internal List<EnumMember> Enums => _enums ?? (_enums = new List<EnumMember>());

		internal bool HasEnums
		{
			get
			{
				if (_enums != null)
				{
					return _enums.Count != 0;
				}
				return false;
			}
		}

		public bool EnumPassthru
		{
			[Obsolete("Enum value maps have been deprecated and are no longer supported; all enums are now effectively pass-thru; custom maps should be applied via shadow properties; in C#, lambda-based 'switch expressions' make for very convenient shadow properties", false)]
			get
			{
				return Type.IsEnum;
			}
			[Obsolete("Enum value maps have been deprecated and are no longer supported; all enums are now effectively pass-thru; custom maps should be applied via shadow properties; in C#, lambda-based 'switch expressions' make for very convenient shadow properties", true)]
			set
			{
				if (value != EnumPassthru)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
				}
			}
		}

		public bool IgnoreListHandling
		{
			get
			{
				return HasFlag(TypeOptions.IgnoreListHandling);
			}
			set
			{
				SetFlag(TypeOptions.IgnoreListHandling, value, throwIfFrozen: true);
				model.ResetServiceCache(Type);
			}
		}

		public bool IgnoreUnknownSubTypes
		{
			get
			{
				return HasFlag(TypeOptions.IgnoreUnknownSubTypes);
			}
			set
			{
				SetFlag(TypeOptions.IgnoreUnknownSubTypes, value, throwIfFrozen: true);
			}
		}

		internal bool Pending
		{
			get
			{
				return HasFlag(TypeOptions.Pending);
			}
			set
			{
				SetFlag(TypeOptions.Pending, value, throwIfFrozen: false);
			}
		}

		public Type SerializerType
		{
			get
			{
				return _serializerType;
			}
			set
			{
				if (value != _serializerType)
				{
					if (!value.IsClass)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("Custom serializer providers must be classes", "SerializerType");
					}
					ThrowIfFrozen();
					_serializerType = value;
				}
			}
		}

		internal bool IsAutoTuple => HasFlag(TypeOptions.AutoTuple);

		public bool IsGroup
		{
			get
			{
				return HasFlag(TypeOptions.IsGroup);
			}
			set
			{
				SetFlag(TypeOptions.IsGroup, value, throwIfFrozen: true);
			}
		}

		internal bool HasReservations => (_reservations?.Count ?? 0) != 0;

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

		private bool IsValidSubType(Type subType)
		{
			if ((object)subType != null && !subType.IsValueType)
			{
				return Type.IsAssignableFrom(subType);
			}
			return false;
		}

		public MetaType AddSubType(int fieldNumber, Type derivedType)
		{
			return AddSubType(fieldNumber, derivedType, DataFormat.Default);
		}

		private static void ThrowSubTypeWithSurrogate(Type type)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Types with surrogates cannot be used in inheritance hierarchies: " + type.NormalizeName());
		}

		public MetaType AddSubType(int fieldNumber, Type derivedType, DataFormat dataFormat)
		{
			if ((object)derivedType == null)
			{
				throw new ArgumentNullException("derivedType");
			}
			if (fieldNumber < 1)
			{
				throw new ArgumentOutOfRangeException("fieldNumber");
			}
			if ((!Type.IsClass && !Type.IsInterface) || Type.IsSealed)
			{
				throw new InvalidOperationException("Sub-types can only be added to non-sealed classes: " + Type.NormalizeName());
			}
			if (!IsValidSubType(derivedType))
			{
				throw new ArgumentException(derivedType.NormalizeName() + " is not a valid sub-type of " + Type.NormalizeName(), "derivedType");
			}
			int opaqueToken = 0;
			try
			{
				model.TakeLock(ref opaqueToken);
				MetaType metaType = model[derivedType];
				ThrowIfFrozen();
				metaType.ThrowIfFrozen();
				if (IsAutoTuple || metaType.IsAutoTuple)
				{
					ThrowTupleTypeWithInheritance(derivedType);
				}
				if ((object)surrogateType != null)
				{
					ThrowSubTypeWithSurrogate(Type);
				}
				if ((object)metaType.surrogateType != null)
				{
					ThrowSubTypeWithSurrogate(derivedType);
				}
				SubType item = new SubType(fieldNumber, metaType, dataFormat);
				ThrowIfFrozen();
				metaType.SetBaseType(this);
				(_subTypes ?? (_subTypes = new List<SubType>())).Add(item);
				return this;
			}
			finally
			{
				model.ReleaseLock(opaqueToken);
			}
		}

		private static void ThrowTupleTypeWithInheritance(Type type)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Tuple-based types cannot be used in inheritance hierarchies: " + type.NormalizeName());
		}

		private void SetBaseType(MetaType baseType)
		{
			if (baseType == null)
			{
				throw new ArgumentNullException("baseType");
			}
			if (this.baseType == baseType)
			{
				return;
			}
			if (this.baseType != null)
			{
				throw new InvalidOperationException("Type '" + this.baseType.Type.FullName + "' can only participate in one inheritance hierarchy");
			}
			for (MetaType metaType = baseType; metaType != null; metaType = metaType.baseType)
			{
				if (metaType == this)
				{
					throw new InvalidOperationException("Cyclic inheritance of '" + this.baseType.Type.FullName + "' is not allowed");
				}
			}
			this.baseType = baseType;
		}

		public MetaType SetCallbacks(MethodInfo beforeSerialize, MethodInfo afterSerialize, MethodInfo beforeDeserialize, MethodInfo afterDeserialize)
		{
			CheckSetCallbacks();
			CallbackSet callbackSet = Callbacks;
			callbackSet.BeforeSerialize = beforeSerialize;
			callbackSet.AfterSerialize = afterSerialize;
			callbackSet.BeforeDeserialize = beforeDeserialize;
			callbackSet.AfterDeserialize = afterDeserialize;
			return this;
		}

		private void CheckSetCallbacks()
		{
			ThrowIfFrozen();
			ThrowIfAutoTuple();
		}

		public MetaType SetCallbacks(string beforeSerialize, string afterSerialize, string beforeDeserialize, string afterDeserialize)
		{
			CheckSetCallbacks();
			CallbackSet callbackSet = Callbacks;
			callbackSet.BeforeSerialize = ResolveMethod(beforeSerialize, instance: true);
			callbackSet.AfterSerialize = ResolveMethod(afterSerialize, instance: true);
			callbackSet.BeforeDeserialize = ResolveMethod(beforeDeserialize, instance: true);
			callbackSet.AfterDeserialize = ResolveMethod(afterDeserialize, instance: true);
			return this;
		}

		public string GetSchemaTypeName()
		{
			return GetSchemaTypeName(null);
		}

		internal string GetSchemaTypeName(HashSet<Type> callstack)
		{
			if (callstack == null)
			{
				callstack = new HashSet<Type>();
			}
			if (!callstack.Add(Type))
			{
				return Type.Name;
			}
			try
			{
				if ((object)surrogateType != null && !callstack.Contains(surrogateType))
				{
					return model[surrogateType].GetSchemaTypeName(callstack);
				}
				if (!string.IsNullOrEmpty(name))
				{
					return name;
				}
				string text = Type.Name;
				if (Type.IsArray)
				{
					return GetArrayName(Type.GetElementType());
				}
				if (Type.IsGenericType)
				{
					StringBuilder stringBuilder = new StringBuilder(text);
					int num = text.IndexOf('`');
					if (num >= 0)
					{
						stringBuilder.Length = num;
					}
					Type[] genericArguments = Type.GetGenericArguments();
					foreach (Type type in genericArguments)
					{
						stringBuilder.Append('_');
						Type type2 = type;
						MetaType metaType;
						if (model.IsDefined(type2) && (metaType = model[type2]) != null)
						{
							stringBuilder.Append(LastPart(metaType.GetSchemaTypeName(callstack)));
							continue;
						}
						if (type2.IsArray)
						{
							stringBuilder.Append(GetArrayName(type2.GetElementType()));
							continue;
						}
						metaType = null;
						try
						{
							metaType = model.Add(type2);
						}
						catch
						{
						}
						if (metaType != null)
						{
							stringBuilder.Append(metaType.GetSchemaTypeName(callstack));
						}
						else
						{
							stringBuilder.Append(type2.Name);
						}
					}
					return stringBuilder.ToString();
				}
				return text;
			}
			finally
			{
				callstack.Remove(Type);
			}
			string GetArrayName(Type elementType)
			{
				MetaType metaType2;
				string text2 = ((model.IsDefined(elementType) && (metaType2 = model[elementType]) != null) ? metaType2.GetSchemaTypeName(callstack) : elementType.Name);
				return "Array_" + text2;
			}
			static string LastPart(string value)
			{
				if (string.IsNullOrWhiteSpace(value))
				{
					return value;
				}
				int num2 = value.LastIndexOf('.');
				if (num2 >= 0)
				{
					return value.Substring(num2 + 1);
				}
				return value;
			}
		}

		internal string GuessPackage()
		{
			string text = Name;
			if (string.IsNullOrWhiteSpace(text))
			{
				return null;
			}
			if (text[0] != '.')
			{
				return null;
			}
			return text[..text.LastIndexOf('.')].Trim(new char[1] { '.' }).Trim();
		}

		public MetaType SetFactory(MethodInfo factory)
		{
			RuntimeTypeModel.VerifyFactory(factory, Type);
			ThrowIfFrozen();
			ThrowIfAutoTuple();
			this.factory = factory;
			return this;
		}

		public MetaType SetFactory(string factory)
		{
			return SetFactory(ResolveMethod(factory, instance: false));
		}

		private MethodInfo ResolveMethod(string name, bool instance)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			if (!instance)
			{
				return Helpers.GetStaticMethod(Type, name);
			}
			return Helpers.GetInstanceMethod(Type, name);
		}

		internal static Exception InbuiltType(Type type, Exception innerException = null)
		{
			string message = "Data of this type has inbuilt behaviour, and cannot be added to a model in this way: " + type.FullName;
			if (innerException != null)
			{
				return new ArgumentException(message, innerException);
			}
			return new ArgumentException(message);
		}

		internal MetaType(RuntimeTypeModel model, Type type, MethodInfo factory)
		{
			this.factory = factory;
			if (model == null)
			{
				throw new ArgumentNullException("model");
			}
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			IRuntimeProtoSerializerNode runtimeProtoSerializerNode = model.TryGetBasicTypeSerializer(type);
			if (runtimeProtoSerializerNode != null)
			{
				throw InbuiltType(type);
			}
			Type = type;
			if (type.IsArray)
			{
				SetFlag(TypeOptions.Frozen, value: true, throwIfFrozen: false);
			}
			this.model = model;
		}

		internal void ThrowIfFrozen()
		{
			if ((flags & TypeOptions.Frozen) != 0)
			{
				throw new InvalidOperationException("The type cannot be changed once a serializer has been generated for " + Type.FullName);
			}
		}

		internal Type GetInheritanceRoot()
		{
			if (Type.IsValueType)
			{
				return null;
			}
			MetaType rootType = GetRootType(this);
			if (rootType != this)
			{
				return rootType.Type;
			}
			if (_subTypes != null && _subTypes.Count != 0)
			{
				return rootType.Type;
			}
			return null;
		}

		private SerializerFeatures GetFeatures()
		{
			if (Type.IsEnum)
			{
				return SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;
			}
			if (!Type.IsValueType)
			{
				MetaType rootType = GetRootType(this);
				if (rootType != this)
				{
					return rootType.GetFeatures();
				}
			}
			SerializerFeatures serializerFeatures = SerializerFeatures.CategoryMessage;
			return serializerFeatures | (IsGroup ? SerializerFeatures.WireTypeStartGroup : SerializerFeatures.WireTypeString);
		}

		private bool HasRealInheritance()
		{
			if (baseType == null || baseType == this)
			{
				return (_subTypes?.Count ?? 0) > 0;
			}
			return true;
		}

		private IProtoTypeSerializer BuildSerializer()
		{
			if ((object)SerializerType != null)
			{
				return ExternalSerializer.Create(Type, SerializerType);
			}
			Validate();
			RepeatedSerializerStub repeatedSerializerStub = model.TryGetRepeatedProvider(Type);
			if (repeatedSerializerStub != null)
			{
				if ((object)surrogateType != null)
				{
					throw new ArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot use a surrogate");
				}
				if (_subTypes != null && _subTypes.Count != 0)
				{
					throw new ArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot be subclassed");
				}
				ValueMember valueMember = new ValueMember(model, 1, Type, repeatedSerializerStub.ItemType, null, DataFormat.Default)
				{
					CompatibilityLevel = CompatibilityLevel
				};
				return TypeSerializer.Create(Type, new int[1] { 1 }, new IRuntimeProtoSerializerNode[1] { valueMember.Serializer }, null, isRootType: true, useConstructor: true, !IgnoreUnknownSubTypes, null, constructType, factory, GetInheritanceRoot(), GetFeatures());
			}
			bool flag = HasRealInheritance();
			if ((object)surrogateType != null)
			{
				if (flag)
				{
					ThrowSubTypeWithSurrogate(Type);
				}
				WireType defaultWireType;
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode = ValueMember.TryGetCoreSerializer(Model, surrogateDataFormat, CompatibilityLevel, surrogateType, out defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false);
				SerializerFeatures features;
				if (runtimeProtoSerializerNode != null)
				{
					try
					{
						features = ExternalSerializer.Create(surrogateType, typeof(PrimaryTypeProvider)).Features;
					}
					catch (Exception innerException)
					{
						throw InbuiltType(surrogateType, innerException);
					}
				}
				else
				{
					MetaType metaType = model[surrogateType];
					MetaType metaType2;
					while ((metaType2 = metaType.baseType) != null)
					{
						if (metaType.HasRealInheritance())
						{
							ThrowSubTypeWithSurrogate(metaType.Type);
						}
						metaType = metaType2;
					}
					IProtoTypeSerializer serializer = metaType.Serializer;
					features = serializer.Features;
					runtimeProtoSerializerNode = serializer;
				}
				return (IProtoTypeSerializer)Activator.CreateInstance(typeof(SurrogateSerializer<>).MakeGenericType(Type), surrogateType, underlyingToSurrogate, surrogateToUnderlying, runtimeProtoSerializerNode, features);
			}
			if (IsAutoTuple)
			{
				if (flag)
				{
					ThrowTupleTypeWithInheritance(Type);
				}
				MemberInfo[] mappedMembers;
				ConstructorInfo constructorInfo = ResolveTupleConstructor(Type, out mappedMembers);
				if ((object)constructorInfo == null)
				{
					throw new InvalidOperationException();
				}
				return (IProtoTypeSerializer)Activator.CreateInstance(typeof(TupleSerializer<>).MakeGenericType(Type), model, constructorInfo, mappedMembers, GetFeatures(), CompatibilityLevel);
			}
			if (HasFields)
			{
				Fields.TrimExcess();
			}
			if (HasEnums)
			{
				Enums.TrimExcess();
			}
			int num = _fields?.Count ?? 0;
			int num2 = _subTypes?.Count ?? 0;
			int[] array = new int[num + num2];
			IRuntimeProtoSerializerNode[] array2 = new IRuntimeProtoSerializerNode[num + num2];
			int num3 = 0;
			if (num2 != 0)
			{
				foreach (SubType subType in _subTypes)
				{
					if (!subType.DerivedType.IgnoreListHandling && model.TryGetRepeatedProvider(subType.DerivedType.Type) != null)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot be used as a subclass");
					}
					array[num3] = subType.FieldNumber;
					array2[num3++] = subType.GetSerializer(Type);
				}
			}
			if (num != 0)
			{
				foreach (ValueMember field in _fields)
				{
					array[num3] = field.FieldNumber;
					array2[num3++] = field.Serializer;
				}
			}
			List<MethodInfo> list = null;
			for (MetaType metaType3 = BaseType; metaType3 != null; metaType3 = metaType3.BaseType)
			{
				MethodInfo methodInfo = (metaType3.HasCallbacks ? metaType3.Callbacks.BeforeDeserialize : null);
				if ((object)methodInfo != null)
				{
					(list ?? (list = new List<MethodInfo>())).Add(methodInfo);
				}
			}
			MethodInfo[] array3 = null;
			if (list != null)
			{
				array3 = new MethodInfo[list.Count];
				list.CopyTo(array3, 0);
				Array.Reverse((Array)array3);
			}
			return TypeSerializer.Create(Type, array, array2, array3, baseType == null, UseConstructor, !IgnoreUnknownSubTypes, callbacks, constructType, factory, GetInheritanceRoot(), GetFeatures());
		}

		private static Type GetBaseType(MetaType type)
		{
			return type.Type.BaseType;
		}

		internal static bool GetAsReferenceDefault(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (type.IsEnum)
			{
				return false;
			}
			AttributeMap[] array = AttributeMap.Create(type, inherit: false);
			for (int i = 0; i < array.Length; i++)
			{
				if (array[i].AttributeType.FullName == "ProtoBuf.ProtoContractAttribute" && array[i].TryGet("AsReferenceDefault", out var value))
				{
					return (bool)value;
				}
			}
			return false;
		}

		internal void ApplyDefaultBehaviour(CompatibilityLevel ambient)
		{
			TypeAddedEventArgs args = null;
			RuntimeTypeModel.OnBeforeApplyDefaultBehaviour(this, ref args);
			if (args == null || args.ApplyDefaultBehaviour)
			{
				ApplyDefaultBehaviourImpl(ambient);
			}
			RuntimeTypeModel.OnAfterApplyDefaultBehaviour(this, ref args);
		}

		private void ApplyDefaultBehaviourImpl(CompatibilityLevel ambient)
		{
			Type type = GetBaseType(this);
			if ((object)type != null && model.FindWithoutAdd(type) == null && GetContractFamily(model, type, null) != 0)
			{
				model.FindOrAddAuto(type, demand: true, addWithContractOnly: false, addEvenIfAutoDisabled: false, ambient);
			}
			AttributeMap[] array = AttributeMap.Create(Type, inherit: false);
			AttributeFamily attributeFamily = GetContractFamily(model, Type, array);
			if (attributeFamily == AttributeFamily.AutoTuple)
			{
				SetFlag(TypeOptions.AutoTuple, value: true, throwIfFrozen: true);
			}
			CompatibilityLevel compatibilityLevel = CompatibilityLevel;
			if (compatibilityLevel <= CompatibilityLevel.NotSpecified)
			{
				if (IsAutoTuple)
				{
					compatibilityLevel = ambient;
				}
				if (compatibilityLevel <= CompatibilityLevel.NotSpecified)
				{
					compatibilityLevel = Model.DefaultCompatibilityLevel;
				}
				CompatibilityLevel = TypeCompatibilityHelper.GetTypeCompatibilityLevel(Type, compatibilityLevel);
			}
			bool isEnum = Type.IsEnum;
			if (attributeFamily == AttributeFamily.None && !isEnum)
			{
				return;
			}
			List<string> list = null;
			List<AttributeMap> list2 = null;
			int dataMemberOffset = 0;
			int num = 1;
			bool flag = model.InferTagFromNameDefault;
			ImplicitFields implicitFields = ImplicitFields.None;
			string text = null;
			string text2 = null;
			foreach (AttributeMap attributeMap in array)
			{
				string fullName = attributeMap.AttributeType.FullName;
				object value;
				if (!isEnum && fullName == "ProtoBuf.ProtoIncludeAttribute")
				{
					int fieldNumber = 0;
					if (attributeMap.TryGet("tag", out value))
					{
						fieldNumber = (int)value;
					}
					DataFormat dataFormat = DataFormat.Default;
					if (attributeMap.TryGet("DataFormat", out value))
					{
						dataFormat = (DataFormat)(int)value;
					}
					Type type2 = null;
					try
					{
						if (attributeMap.TryGet("knownTypeName", out value))
						{
							type2 = TypeModel.ResolveKnownType((string)value, Type.Assembly);
						}
						else if (attributeMap.TryGet("knownType", out value))
						{
							type2 = (Type)value;
						}
					}
					catch (Exception innerException)
					{
						throw new InvalidOperationException("Unable to resolve sub-type of: " + Type.FullName, innerException);
					}
					if ((object)type2 == null)
					{
						throw new InvalidOperationException("Unable to resolve sub-type of: " + Type.FullName);
					}
					if (IsValidSubType(type2))
					{
						AddSubType(fieldNumber, type2, dataFormat);
					}
				}
				if (fullName == "ProtoBuf.ProtoPartialIgnoreAttribute" && attributeMap.TryGet("MemberName", out value) && value != null)
				{
					(list ?? (list = new List<string>())).Add((string)value);
				}
				if (!isEnum && fullName == "ProtoBuf.ProtoPartialMemberAttribute")
				{
					(list2 ?? (list2 = new List<AttributeMap>())).Add(attributeMap);
				}
				if (fullName == "ProtoBuf.ProtoContractAttribute")
				{
					if (attributeMap.TryGet("Name", out value))
					{
						text = (string)value;
					}
					if (attributeMap.TryGet("Origin", out value))
					{
						text2 = (string)value;
					}
					if (!Type.IsEnum)
					{
						if (attributeMap.TryGet("DataMemberOffset", out value))
						{
							dataMemberOffset = (int)value;
						}
						if (attributeMap.TryGet("InferTagFromNameHasValue", publicOnly: false, out value) && (bool)value && attributeMap.TryGet("InferTagFromName", out value))
						{
							flag = (bool)value;
						}
						if (attributeMap.TryGet("ImplicitFields", out value) && value != null)
						{
							implicitFields = (ImplicitFields)(int)value;
						}
						if (attributeMap.TryGet("SkipConstructor", out value))
						{
							UseConstructor = !(bool)value;
						}
						if (attributeMap.TryGet("IgnoreListHandling", out value))
						{
							IgnoreListHandling = (bool)value;
						}
						if (attributeMap.TryGet("ImplicitFirstTag", out value) && (int)value > 0)
						{
							num = (int)value;
						}
						if (attributeMap.TryGet("IsGroup", out value))
						{
							IsGroup = (bool)value;
						}
						if (attributeMap.TryGet("IgnoreUnknownSubTypes", out value))
						{
							IgnoreUnknownSubTypes = (bool)value;
						}
						if (attributeMap.TryGet("Surrogate", out value))
						{
							SetSurrogate((Type)value);
						}
						if (attributeMap.TryGet("Serializer", out value))
						{
							SerializerType = (Type)value;
						}
					}
				}
				if (fullName == "System.Runtime.Serialization.DataContractAttribute" && text == null && attributeMap.TryGet("Name", out value))
				{
					text = (string)value;
				}
				if (fullName == "System.Xml.Serialization.XmlTypeAttribute" && text == null && attributeMap.TryGet("TypeName", out value))
				{
					text = (string)value;
				}
				if (fullName == "ProtoBuf.ProtoReservedAttribute" && attributeMap.Target is ProtoReservedAttribute reservation)
				{
					AddReservation(reservation);
				}
			}
			if (!string.IsNullOrEmpty(text))
			{
				Name = text;
			}
			if (text2 != null)
			{
				Origin = text2;
			}
			if (implicitFields != 0)
			{
				attributeFamily &= AttributeFamily.ProtoBuf;
			}
			MethodInfo[] array2 = null;
			List<ProtoMemberAttribute> list3 = new List<ProtoMemberAttribute>();
			List<EnumMember> list4 = new List<EnumMember>();
			MemberInfo[] members = Type.GetMembers(isEnum ? (BindingFlags.Static | BindingFlags.Public) : (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
			MemberInfo[] array3 = members;
			foreach (MemberInfo memberInfo in array3)
			{
				if (memberInfo.DeclaringType != Type || memberInfo.IsDefined(typeof(ProtoIgnoreAttribute), inherit: true) || (list != null && list.Contains(memberInfo.Name)))
				{
					continue;
				}
				bool forced = false;
				if (memberInfo is PropertyInfo propertyInfo)
				{
					if (isEnum)
					{
						continue;
					}
					MemberInfo backingMember = null;
					if (!propertyInfo.CanWrite)
					{
						string text3 = "<" + propertyInfo.Name + ">k__BackingField";
						MemberInfo[] array4 = members;
						foreach (MemberInfo memberInfo2 in array4)
						{
							if (memberInfo2 is FieldInfo && memberInfo2.Name == text3)
							{
								backingMember = memberInfo2;
								break;
							}
						}
					}
					Type effectiveType = propertyInfo.PropertyType;
					bool isPublic = (object)Helpers.GetGetMethod(propertyInfo, nonPublic: false, allowInternal: false) != null;
					bool isField = false;
					ApplyDefaultBehaviour_AddMembers(attributeFamily, isEnum, list2, dataMemberOffset, flag, implicitFields, list3, memberInfo, ref forced, isPublic, isField, ref effectiveType, list4, backingMember);
				}
				else if (memberInfo is FieldInfo fieldInfo)
				{
					Type effectiveType = fieldInfo.FieldType;
					bool isPublic = fieldInfo.IsPublic;
					bool isField = true;
					if (!isEnum || fieldInfo.IsStatic)
					{
						ApplyDefaultBehaviour_AddMembers(attributeFamily, isEnum, list2, dataMemberOffset, flag, implicitFields, list3, memberInfo, ref forced, isPublic, isField, ref effectiveType, list4);
					}
				}
				else if (memberInfo is MethodInfo methodInfo && !isEnum)
				{
					AttributeMap[] array5 = AttributeMap.Create(methodInfo, inherit: false);
					if (array5 != null && array5.Length != 0)
					{
						CheckForCallback(methodInfo, array5, "ProtoBuf.ProtoBeforeSerializationAttribute", ref array2, 0);
						CheckForCallback(methodInfo, array5, "ProtoBuf.ProtoAfterSerializationAttribute", ref array2, 1);
						CheckForCallback(methodInfo, array5, "ProtoBuf.ProtoBeforeDeserializationAttribute", ref array2, 2);
						CheckForCallback(methodInfo, array5, "ProtoBuf.ProtoAfterDeserializationAttribute", ref array2, 3);
						CheckForCallback(methodInfo, array5, "System.Runtime.Serialization.OnSerializingAttribute", ref array2, 4);
						CheckForCallback(methodInfo, array5, "System.Runtime.Serialization.OnSerializedAttribute", ref array2, 5);
						CheckForCallback(methodInfo, array5, "System.Runtime.Serialization.OnDeserializingAttribute", ref array2, 6);
						CheckForCallback(methodInfo, array5, "System.Runtime.Serialization.OnDeserializedAttribute", ref array2, 7);
					}
				}
			}
			if (flag || implicitFields != 0)
			{
				list3.Sort();
				int num2 = num;
				foreach (ProtoMemberAttribute item in list3)
				{
					if (!item.TagIsPinned)
					{
						item.Rebase(num2++);
					}
				}
			}
			foreach (ProtoMemberAttribute item2 in list3)
			{
				ValueMember valueMember = ApplyDefaultBehaviour(isEnum, item2);
				if (valueMember != null)
				{
					Add(valueMember);
				}
			}
			foreach (EnumMember item3 in list4)
			{
				Enums.Add(item3);
			}
			if (array2 != null)
			{
				SetCallbacks(Coalesce(array2, 0, 4), Coalesce(array2, 1, 5), Coalesce(array2, 2, 6), Coalesce(array2, 3, 7));
			}
		}

		internal void Assert(CompatibilityLevel expected)
		{
			CompatibilityLevel compatibilityLevel = CompatibilityLevel;
			if (compatibilityLevel != expected)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"The expected ('{expected}') and actual ('{compatibilityLevel}') compatibility level of '{Type.NormalizeName()}' did not match; the same type cannot be used with different compatibility levels in the same model; this is most commonly an issue with tuple-like types in different contexts");
			}
		}

		private static void ApplyDefaultBehaviour_AddMembers(AttributeFamily family, bool isEnum, List<AttributeMap> partialMembers, int dataMemberOffset, bool inferTagByName, ImplicitFields implicitMode, List<ProtoMemberAttribute> members, MemberInfo member, ref bool forced, bool isPublic, bool isField, ref Type effectiveType, List<EnumMember> enumMembers, MemberInfo backingMember = null)
		{
			switch (implicitMode)
			{
			case ImplicitFields.AllFields:
				if (isField)
				{
					forced = true;
				}
				break;
			case ImplicitFields.AllPublic:
				if (isPublic)
				{
					forced = true;
				}
				break;
			}
			if (effectiveType.IsSubclassOf(typeof(Delegate)))
			{
				effectiveType = null;
			}
			if ((object)effectiveType != null)
			{
				EnumMember enumMember;
				ProtoMemberAttribute protoMemberAttribute = NormalizeProtoMember(member, family, forced, isEnum, partialMembers, dataMemberOffset, inferTagByName, out enumMember, backingMember);
				if (protoMemberAttribute != null)
				{
					members.Add(protoMemberAttribute);
				}
				if (enumMember.HasValue)
				{
					enumMembers.Add(enumMember);
				}
			}
		}

		private static MethodInfo Coalesce(MethodInfo[] arr, int x, int y)
		{
			return arr[x] ?? arr[y];
		}

		internal static AttributeFamily GetContractFamily(RuntimeTypeModel model, Type type, AttributeMap[] attributes)
		{
			AttributeFamily attributeFamily = AttributeFamily.None;
			if (attributes == null)
			{
				attributes = AttributeMap.Create(type, inherit: false);
			}
			for (int i = 0; i < attributes.Length; i++)
			{
				switch (attributes[i].AttributeType.FullName)
				{
				case "ProtoBuf.ProtoContractAttribute":
				{
					bool value = false;
					GetFieldBoolean(ref value, attributes[i], "UseProtoMembersOnly");
					if (value)
					{
						return AttributeFamily.ProtoBuf;
					}
					attributeFamily |= AttributeFamily.ProtoBuf;
					break;
				}
				case "System.Xml.Serialization.XmlTypeAttribute":
					if (!model.AutoAddProtoContractTypesOnly)
					{
						attributeFamily |= AttributeFamily.XmlSerializer;
					}
					break;
				case "System.Runtime.Serialization.DataContractAttribute":
					if (!model.AutoAddProtoContractTypesOnly)
					{
						attributeFamily |= AttributeFamily.DataContractSerializer;
					}
					break;
				}
			}
			if (attributeFamily == AttributeFamily.None && (object)ResolveTupleConstructor(type, out var _) != null)
			{
				attributeFamily |= AttributeFamily.AutoTuple;
			}
			return attributeFamily;
		}

		internal static ConstructorInfo ResolveTupleConstructor(Type type, out MemberInfo[] mappedMembers)
		{
			mappedMembers = null;
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (type.IsAbstract)
			{
				return null;
			}
			ConstructorInfo[] constructors = Helpers.GetConstructors(type, nonPublic: false);
			if (constructors.Length == 0 || (constructors.Length == 1 && constructors[0].GetParameters().Length == 0))
			{
				return null;
			}
			MemberInfo[] instanceFieldsAndProperties = Helpers.GetInstanceFieldsAndProperties(type, publicOnly: true);
			List<MemberInfo> list = new List<MemberInfo>();
			bool flag = type.Name.IndexOf("Tuple", StringComparison.OrdinalIgnoreCase) < 0;
			for (int i = 0; i < instanceFieldsAndProperties.Length; i++)
			{
				if (instanceFieldsAndProperties[i] is PropertyInfo propertyInfo)
				{
					if (!propertyInfo.CanRead)
					{
						return null;
					}
					if (flag && propertyInfo.CanWrite && IsPublicSetter(Helpers.GetSetMethod(propertyInfo, nonPublic: false, allowInternal: false)))
					{
						return null;
					}
					list.Add(propertyInfo);
				}
				else if (instanceFieldsAndProperties[i] is FieldInfo fieldInfo)
				{
					if (flag && !fieldInfo.IsInitOnly)
					{
						return null;
					}
					list.Add(fieldInfo);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			MemberInfo[] array = new MemberInfo[list.Count];
			list.CopyTo(array, 0);
			int[] array2 = new int[array.Length];
			int num = 0;
			ConstructorInfo result = null;
			mappedMembers = new MemberInfo[array2.Length];
			for (int j = 0; j < constructors.Length; j++)
			{
				ParameterInfo[] parameters = constructors[j].GetParameters();
				if (parameters.Length != array.Length)
				{
					continue;
				}
				for (int k = 0; k < array2.Length; k++)
				{
					array2[k] = -1;
				}
				for (int l = 0; l < parameters.Length; l++)
				{
					for (int m = 0; m < array.Length; m++)
					{
						if (string.Compare(parameters[l].Name, array[m].Name, StringComparison.OrdinalIgnoreCase) == 0)
						{
							Type memberType = Helpers.GetMemberType(array[m]);
							if (!(memberType != parameters[l].ParameterType))
							{
								array2[l] = m;
							}
						}
					}
				}
				bool flag2 = false;
				for (int n = 0; n < array2.Length; n++)
				{
					if (array2[n] < 0)
					{
						flag2 = true;
						break;
					}
					mappedMembers[n] = array[array2[n]];
				}
				if (!flag2)
				{
					num++;
					result = constructors[j];
				}
			}
			if (num != 1)
			{
				return null;
			}
			return result;
			static bool IsPublicSetter(MethodInfo method)
			{
				if ((object)method == null)
				{
					return false;
				}
				Type[] array3 = method.ReturnParameter?.GetRequiredCustomModifiers() ?? Type.EmptyTypes;
				for (int num2 = 0; num2 < array3.Length; num2++)
				{
					if (array3[num2]?.FullName == "System.Runtime.CompilerServices.IsExternalInit")
					{
						return false;
					}
				}
				return true;
			}
		}

		private static void CheckForCallback(MethodInfo method, AttributeMap[] attributes, string callbackTypeName, ref MethodInfo[] callbacks, int index)
		{
			for (int i = 0; i < attributes.Length; i++)
			{
				if (attributes[i].AttributeType.FullName == callbackTypeName)
				{
					if (callbacks == null)
					{
						callbacks = new MethodInfo[8];
					}
					else if ((object)callbacks[index] != null)
					{
						Type reflectedType = method.ReflectedType;
						throw new ProtoException("Duplicate " + callbackTypeName + " callbacks on " + reflectedType.FullName);
					}
					callbacks[index] = method;
				}
			}
		}

		private static bool HasFamily(AttributeFamily value, AttributeFamily required)
		{
			return (value & required) == required;
		}

		private static ProtoMemberAttribute NormalizeProtoMember(MemberInfo member, AttributeFamily family, bool forced, bool isEnum, List<AttributeMap> partialMembers, int dataMemberOffset, bool inferByTagName, out EnumMember enumMember, MemberInfo backingMember = null)
		{
			enumMember = default(EnumMember);
			if ((object)member == null || (family == AttributeFamily.None && !isEnum))
			{
				return null;
			}
			int value = int.MinValue;
			int num = ((!inferByTagName) ? 1 : (-1));
			string text = null;
			bool value2 = false;
			bool ignore = false;
			bool flag = false;
			bool value3 = false;
			bool value4 = false;
			bool value5 = false;
			bool value6 = false;
			bool tagIsPinned = false;
			bool value7 = false;
			DataFormat value8 = DataFormat.Default;
			if (isEnum)
			{
				forced = true;
			}
			AttributeMap[] attribs = AttributeMap.Create(member, inherit: true);
			if (isEnum)
			{
				if (GetAttribute(attribs, "ProtoBuf.ProtoIgnoreAttribute") == null)
				{
					AttributeMap attribute = GetAttribute(attribs, "ProtoBuf.ProtoEnumAttribute");
					object rawConstantValue = ((FieldInfo)member).GetRawConstantValue();
					if (attribute != null)
					{
						GetFieldName(ref text, attribute, "Name");
					}
					if (string.IsNullOrWhiteSpace(text))
					{
						text = member.Name;
					}
					enumMember = new EnumMember(rawConstantValue, text);
				}
				return null;
			}
			if (!ignore && !flag)
			{
				AttributeMap attribute = GetAttribute(attribs, "ProtoBuf.ProtoMemberAttribute");
				GetIgnore(ref ignore, attribute, attribs, "ProtoBuf.ProtoIgnoreAttribute");
				if (!ignore && attribute != null)
				{
					GetFieldNumber(ref value, attribute, "Tag");
					GetFieldName(ref text, attribute, "Name");
					GetFieldBoolean(ref value3, attribute, "IsRequired");
					GetFieldBoolean(ref value2, attribute, "IsPacked");
					GetFieldBoolean(ref value7, attribute, "OverwriteList");
					GetDataFormat(ref value8, attribute, "DataFormat");
					GetFieldBoolean(ref value5, attribute, "AsReferenceHasValue", publicOnly: false);
					if (value5)
					{
						value5 = GetFieldBoolean(ref value4, attribute, "AsReference", publicOnly: true);
					}
					GetFieldBoolean(ref value6, attribute, "DynamicType");
					flag = (tagIsPinned = value > 0);
				}
				if (!flag && partialMembers != null)
				{
					foreach (AttributeMap partialMember in partialMembers)
					{
						if (partialMember.TryGet("MemberName", out var value9) && (string)value9 == member.Name)
						{
							GetFieldNumber(ref value, partialMember, "Tag");
							GetFieldName(ref text, partialMember, "Name");
							GetFieldBoolean(ref value3, partialMember, "IsRequired");
							GetFieldBoolean(ref value2, partialMember, "IsPacked");
							GetFieldBoolean(ref value7, attribute, "OverwriteList");
							GetDataFormat(ref value8, partialMember, "DataFormat");
							GetFieldBoolean(ref value5, attribute, "AsReferenceHasValue", publicOnly: false);
							if (value5)
							{
								value5 = GetFieldBoolean(ref value4, partialMember, "AsReference", publicOnly: true);
							}
							GetFieldBoolean(ref value6, partialMember, "DynamicType");
							if (flag = (tagIsPinned = value > 0))
							{
								break;
							}
						}
					}
				}
			}
			if (!ignore && !flag && HasFamily(family, AttributeFamily.DataContractSerializer))
			{
				AttributeMap attribute = GetAttribute(attribs, "System.Runtime.Serialization.DataMemberAttribute");
				if (attribute != null)
				{
					GetFieldNumber(ref value, attribute, "Order");
					GetFieldName(ref text, attribute, "Name");
					GetFieldBoolean(ref value3, attribute, "IsRequired");
					flag = value >= num;
					if (flag)
					{
						value += dataMemberOffset;
					}
				}
			}
			if (!ignore && !flag && HasFamily(family, AttributeFamily.XmlSerializer))
			{
				AttributeMap attribute = GetAttribute(attribs, "System.Xml.Serialization.XmlElementAttribute") ?? GetAttribute(attribs, "System.Xml.Serialization.XmlArrayAttribute");
				GetIgnore(ref ignore, attribute, attribs, "System.Xml.Serialization.XmlIgnoreAttribute");
				if (attribute != null && !ignore)
				{
					GetFieldNumber(ref value, attribute, "Order");
					GetFieldName(ref text, attribute, "ElementName");
					flag = value >= num;
				}
			}
			if (!ignore && !flag && GetAttribute(attribs, "System.NonSerializedAttribute") != null)
			{
				ignore = true;
			}
			if (ignore || (value < num && !forced))
			{
				return null;
			}
			return new ProtoMemberAttribute(value, forced || inferByTagName)
			{
				DataFormat = value8,
				IsPacked = value2,
				OverwriteList = value7,
				IsRequired = value3,
				Name = (string.IsNullOrEmpty(text) ? member.Name : text),
				Member = member,
				BackingMember = backingMember,
				TagIsPinned = tagIsPinned
			};
		}

		private ValueMember ApplyDefaultBehaviour(bool isEnum, ProtoMemberAttribute normalizedAttribute)
		{
			MemberInfo member;
			if (normalizedAttribute == null || (object)(member = normalizedAttribute.Member) == null)
			{
				return null;
			}
			Type memberType = Helpers.GetMemberType(member);
			CompatibilityLevel memberCompatibilityLevel = TypeCompatibilityHelper.GetMemberCompatibilityLevel(member, CompatibilityLevel);
			RepeatedSerializerStub repeatedSerializerStub = model.TryGetRepeatedProvider(memberType, memberCompatibilityLevel);
			AttributeMap[] attribs = AttributeMap.Create(member, inherit: true);
			object defaultValue = null;
			if (model.UseImplicitZeroDefaults)
			{
				switch (Helpers.GetTypeCode(memberType))
				{
				case ProtoTypeCode.Boolean:
					defaultValue = false;
					break;
				case ProtoTypeCode.Decimal:
					defaultValue = 0m;
					break;
				case ProtoTypeCode.Single:
					defaultValue = 0f;
					break;
				case ProtoTypeCode.Double:
					defaultValue = 0.0;
					break;
				case ProtoTypeCode.Byte:
					defaultValue = (byte)0;
					break;
				case ProtoTypeCode.Char:
					defaultValue = '\0';
					break;
				case ProtoTypeCode.Int16:
					defaultValue = (short)0;
					break;
				case ProtoTypeCode.Int32:
					defaultValue = 0;
					break;
				case ProtoTypeCode.Int64:
					defaultValue = 0L;
					break;
				case ProtoTypeCode.SByte:
					defaultValue = (sbyte)0;
					break;
				case ProtoTypeCode.UInt16:
					defaultValue = (ushort)0;
					break;
				case ProtoTypeCode.UInt32:
					defaultValue = 0u;
					break;
				case ProtoTypeCode.UInt64:
					defaultValue = 0uL;
					break;
				case ProtoTypeCode.TimeSpan:
					defaultValue = TimeSpan.Zero;
					break;
				case ProtoTypeCode.Guid:
					defaultValue = Guid.Empty;
					break;
				case ProtoTypeCode.IntPtr:
					defaultValue = IntPtr.Zero;
					break;
				case ProtoTypeCode.UIntPtr:
					defaultValue = UIntPtr.Zero;
					break;
				}
			}
			AttributeMap attribute;
			if ((attribute = GetAttribute(attribs, "System.ComponentModel.DefaultValueAttribute")) != null && attribute.TryGet("Value", out var value))
			{
				defaultValue = value;
			}
			ValueMember valueMember = ((isEnum || normalizedAttribute.Tag > 0) ? new ValueMember(model, Type, normalizedAttribute.Tag, member, memberType, repeatedSerializerStub?.ItemType, null, normalizedAttribute.DataFormat, defaultValue) : null);
			if (valueMember != null)
			{
				valueMember.CompatibilityLevel = memberCompatibilityLevel;
				valueMember.BackingMember = normalizedAttribute.BackingMember;
				Type type = Type;
				PropertyInfo propertyInfo = Helpers.GetProperty(type, member.Name + "Specified", nonPublic: true);
				MethodInfo getMethod = Helpers.GetGetMethod(propertyInfo, nonPublic: true, allowInternal: true);
				if ((object)getMethod == null || getMethod.IsStatic)
				{
					propertyInfo = null;
				}
				if ((object)propertyInfo != null)
				{
					valueMember.SetSpecified(getMethod, Helpers.GetSetMethod(propertyInfo, nonPublic: true, allowInternal: true));
				}
				else
				{
					MethodInfo instanceMethod = Helpers.GetInstanceMethod(type, "ShouldSerialize" + member.Name, Type.EmptyTypes);
					if ((object)instanceMethod != null && instanceMethod.ReturnType == typeof(bool))
					{
						valueMember.SetSpecified(instanceMethod, null);
					}
				}
				if (!string.IsNullOrEmpty(normalizedAttribute.Name))
				{
					valueMember.SetName(normalizedAttribute.Name);
				}
				valueMember.IsPacked = normalizedAttribute.IsPacked;
				valueMember.IsRequired = normalizedAttribute.IsRequired;
				valueMember.OverwriteList = normalizedAttribute.OverwriteList;
				if (repeatedSerializerStub != null)
				{
					DataFormat dataFormat = DataFormat.Default;
					DataFormat mapValueFormat = DataFormat.Default;
					bool flag = true;
					if ((attribute = GetAttribute(attribs, "ProtoBuf.ProtoMapAttribute")) != null)
					{
						if (attribute.TryGet("DisableMap", out var value2) && (bool)value2)
						{
							flag = false;
						}
						else
						{
							if (attribute.TryGet("KeyFormat", out value2))
							{
								dataFormat = (DataFormat)value2;
							}
							if (attribute.TryGet("ValueFormat", out value2))
							{
								mapValueFormat = (DataFormat)value2;
							}
						}
					}
					if (flag && repeatedSerializerStub.IsValidProtobufMap(model, valueMember.CompatibilityLevel, dataFormat))
					{
						valueMember.MapKeyFormat = dataFormat;
						valueMember.MapValueFormat = mapValueFormat;
						valueMember.IsMap = true;
					}
				}
				if ((attribute = GetAttribute(attribs, typeof(NullWrappedValueAttribute).FullName)) != null)
				{
					valueMember.NullWrappedValue = true;
					if (attribute.TryGet("AsGroup", out var value3) && value3 is bool nullWrappedValueGroup)
					{
						valueMember.NullWrappedValueGroup = nullWrappedValueGroup;
					}
				}
				if ((attribute = GetAttribute(attribs, typeof(NullWrappedCollectionAttribute).FullName)) != null)
				{
					valueMember.NullWrappedCollection = true;
					if (attribute.TryGet("AsGroup", out var value4) && value4 is bool nullWrappedCollectionGroup)
					{
						valueMember.NullWrappedCollectionGroup = nullWrappedCollectionGroup;
					}
				}
			}
			return valueMember;
		}

		private static void GetDataFormat(ref DataFormat value, AttributeMap attrib, string memberName)
		{
			if (attrib != null && value == DataFormat.Default && attrib.TryGet(memberName, out var value2) && value2 != null)
			{
				value = (DataFormat)value2;
			}
		}

		private static void GetIgnore(ref bool ignore, AttributeMap attrib, AttributeMap[] attribs, string fullName)
		{
			if (!ignore && attrib != null)
			{
				ignore = GetAttribute(attribs, fullName) != null;
			}
		}

		private static void GetFieldBoolean(ref bool value, AttributeMap attrib, string memberName)
		{
			GetFieldBoolean(ref value, attrib, memberName, publicOnly: true);
		}

		private static bool GetFieldBoolean(ref bool value, AttributeMap attrib, string memberName, bool publicOnly)
		{
			if (attrib == null)
			{
				return false;
			}
			if (value)
			{
				return true;
			}
			if (attrib.TryGet(memberName, publicOnly, out var value2) && value2 != null)
			{
				value = (bool)value2;
				return true;
			}
			return false;
		}

		private static void GetFieldNumber(ref int value, AttributeMap attrib, string memberName)
		{
			if (attrib != null && value <= 0 && attrib.TryGet(memberName, out var value2) && value2 != null)
			{
				value = (int)value2;
			}
		}

		private static void GetFieldName(ref string name, AttributeMap attrib, string memberName)
		{
			if (attrib != null && string.IsNullOrEmpty(name) && attrib.TryGet(memberName, out var value) && value != null)
			{
				name = (string)value;
			}
		}

		private static AttributeMap GetAttribute(AttributeMap[] attribs, string fullName)
		{
			foreach (AttributeMap attributeMap in attribs)
			{
				if (attributeMap != null && attributeMap.AttributeType.FullName == fullName)
				{
					return attributeMap;
				}
			}
			return null;
		}

		public MetaType Add(int fieldNumber, string memberName)
		{
			AddField(fieldNumber, memberName, null, null, null);
			return this;
		}

		public ValueMember AddField(int fieldNumber, string memberName)
		{
			return AddField(fieldNumber, memberName, null, null, null);
		}

		public MetaType Add(string memberName)
		{
			Add(GetNextFieldNumber(), memberName);
			return this;
		}

		public void SetSurrogate(Type surrogateType)
		{
			SetSurrogate(surrogateType, null, null, DataFormat.Default);
		}

		internal void SetSurrogate(Type surrogateType, MethodInfo underlyingToSurrogate, MethodInfo surrogateToUnderlying, DataFormat dataFormat)
		{
			if (surrogateType == Type)
			{
				surrogateType = null;
			}
			if ((object)surrogateType != null)
			{
				if (surrogateType != typeof(string) && typeof(IEnumerable).IsAssignableFrom(surrogateType))
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("Repeated data (a list, collection, etc) has inbuilt behaviour and cannot be used as a surrogate");
				}
				if ((BaseType != null && BaseType != this) || (_subTypes?.Count ?? 0) > 0)
				{
					ThrowSubTypeWithSurrogate(Type);
				}
				if (surrogateType.IsGenericTypeDefinition)
				{
					if (!Type.IsGenericType)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("Cannot use an open generic type as a surrogate for a non generic type");
					}
					Type[] genericArguments = Type.GetGenericArguments();
					if (genericArguments.Length != surrogateType.GetGenericArguments().Length)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("The generic type parameters of the surrogate must match the generic arguments of the target type");
					}
					surrogateType = surrogateType.MakeGenericType(genericArguments);
				}
			}
			int opaqueToken = 0;
			try
			{
				model.TakeLock(ref opaqueToken);
				ThrowIfFrozen();
				this.surrogateType = surrogateType;
				this.underlyingToSurrogate = underlyingToSurrogate;
				this.surrogateToUnderlying = surrogateToUnderlying;
				surrogateDataFormat = dataFormat;
				SetFlag(TypeOptions.AutoTuple, value: false, throwIfFrozen: false);
			}
			finally
			{
				model.ReleaseLock(opaqueToken);
			}
		}

		internal MetaType GetSurrogateOrSelf()
		{
			if ((object)surrogateType != null)
			{
				return model[surrogateType];
			}
			return this;
		}

		internal MetaType GetSurrogateOrBaseOrSelf(bool deep)
		{
			if ((object)surrogateType != null)
			{
				return model[surrogateType];
			}
			MetaType metaType = baseType;
			if (metaType != null)
			{
				if (deep)
				{
					MetaType result;
					do
					{
						result = metaType;
						metaType = metaType.baseType;
					}
					while (metaType != null);
					return result;
				}
				return metaType;
			}
			return this;
		}

		private int GetNextFieldNumber()
		{
			int num = 0;
			if (HasFields)
			{
				foreach (ValueMember field in Fields)
				{
					if (field.FieldNumber > num)
					{
						num = field.FieldNumber;
					}
				}
			}
			if (_subTypes != null)
			{
				foreach (SubType subType in _subTypes)
				{
					if (subType.FieldNumber > num)
					{
						num = subType.FieldNumber;
					}
				}
			}
			return num + 1;
		}

		public MetaType Add(params string[] memberNames)
		{
			if (memberNames == null)
			{
				throw new ArgumentNullException("memberNames");
			}
			int nextFieldNumber = GetNextFieldNumber();
			for (int i = 0; i < memberNames.Length; i++)
			{
				Add(nextFieldNumber++, memberNames[i]);
			}
			return this;
		}

		public MetaType Add(int fieldNumber, string memberName, object defaultValue)
		{
			AddField(fieldNumber, memberName, null, null, defaultValue);
			return this;
		}

		public MetaType Add(int fieldNumber, string memberName, Type itemType, Type defaultType)
		{
			AddField(fieldNumber, memberName, itemType, defaultType, null);
			return this;
		}

		public ValueMember AddField(int fieldNumber, string memberName, Type itemType, Type defaultType)
		{
			return AddField(fieldNumber, memberName, itemType, defaultType, null);
		}

		private void ThrowIfAutoTuple()
		{
			if (IsAutoTuple)
			{
				Throw();
			}
			static void Throw()
			{
				throw new InvalidOperationException("This operation is not supported for tuple-like types; to disable tuple-like type discovery, use applyDefaultBehaviour: false when first adding the type to the model.");
			}
		}

		private ValueMember AddField(int fieldNumber, string memberName, Type itemType, Type defaultType, object defaultValue)
		{
			MemberInfo memberInfo = null;
			MemberInfo[] member = Type.GetMember(memberName, Type.IsEnum ? (BindingFlags.Static | BindingFlags.Public) : (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
			if (member != null && member.Length == 1)
			{
				memberInfo = member[0];
			}
			if ((object)memberInfo == null)
			{
				throw new ArgumentException("Unable to determine member: " + memberName, "memberName");
			}
			ThrowIfAutoTuple();
			PropertyInfo propertyInfo = null;
			Type type;
			switch (memberInfo.MemberType)
			{
			case MemberTypes.Field:
			{
				FieldInfo fieldInfo = (FieldInfo)memberInfo;
				type = fieldInfo.FieldType;
				break;
			}
			case MemberTypes.Property:
				propertyInfo = (PropertyInfo)memberInfo;
				type = propertyInfo.PropertyType;
				break;
			default:
				throw new NotSupportedException(memberInfo.MemberType.ToString());
			}
			RepeatedSerializerStub repeatedSerializerStub = model.TryGetRepeatedProvider(type);
			if ((object)itemType != null && repeatedSerializerStub?.ItemType != itemType)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Expected item type of " + repeatedSerializerStub?.ItemType.NormalizeName());
			}
			MemberInfo memberInfo2 = null;
			if ((object)propertyInfo != null && !propertyInfo.CanWrite)
			{
				MemberInfo[] member2 = Type.GetMember("<" + ((PropertyInfo)memberInfo).Name + ">k__BackingField", Type.IsEnum ? (BindingFlags.Static | BindingFlags.Public) : (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
				if (member2 != null && member2.Length == 1 && member2[0] is FieldInfo)
				{
					memberInfo2 = member2[0];
				}
			}
			if (repeatedSerializerStub != null)
			{
				if ((object)defaultType != null && defaultType != repeatedSerializerStub.ForType)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("Default types for collections are not currently supported; recommendation: initialize the colleciton in the type");
				}
				defaultType = repeatedSerializerStub.ForType;
			}
			ValueMember valueMember = new ValueMember(model, Type, fieldNumber, memberInfo2 ?? memberInfo, type, repeatedSerializerStub?.ItemType, defaultType, DataFormat.Default, defaultValue)
			{
				CompatibilityLevel = CompatibilityLevel
			};
			if ((object)memberInfo2 != null)
			{
				valueMember.SetName(memberInfo.Name);
			}
			Add(valueMember);
			return valueMember;
		}

		private void Add(ValueMember member)
		{
			if (Type.IsEnum)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Enums should use SetEnumValues to customize the enum definitions");
			}
			int opaqueToken = 0;
			try
			{
				model.TakeLock(ref opaqueToken);
				ThrowIfFrozen();
				Fields.Add(member);
			}
			finally
			{
				model.ReleaseLock(opaqueToken);
			}
		}

		public ValueMember[] GetFields()
		{
			if (!HasFields)
			{
				return Array.Empty<ValueMember>();
			}
			ValueMember[] array = Fields.ToArray();
			Array.Sort(array, ValueMember.Comparer.Default);
			return array;
		}

		public EnumMember[] GetEnumValues()
		{
			if (!HasEnums)
			{
				return Array.Empty<EnumMember>();
			}
			return Enums.ToArray();
		}

		public void SetEnumValues(EnumMember[] values)
		{
			if (!Type.IsEnum)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Only enums should use SetEnumValues");
			}
			if (values == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("values");
			}
			EnumMember[] collection = Array.ConvertAll(values, (EnumMember val) => val.Normalize(Type));
			foreach (EnumMember enumMember in values)
			{
				enumMember.Validate();
			}
			int opaqueToken = 0;
			try
			{
				model.TakeLock(ref opaqueToken);
				ThrowIfFrozen();
				Enums.Clear();
				Enums.AddRange(collection);
			}
			finally
			{
				model.ReleaseLock(opaqueToken);
			}
		}

		internal bool IsValidEnum()
		{
			return IsValidEnum(_enums);
		}

		internal static bool IsValidEnum(IList<EnumMember> values)
		{
			if (values == null || values.Count == 0)
			{
				return false;
			}
			foreach (EnumMember value in values)
			{
				if (!value.TryGetInt32().HasValue)
				{
					return false;
				}
			}
			return true;
		}

		public SubType[] GetSubtypes()
		{
			if (_subTypes == null || _subTypes.Count == 0)
			{
				return Array.Empty<SubType>();
			}
			SubType[] array = _subTypes.ToArray();
			Array.Sort(array, SubType.Comparer.Default);
			return array;
		}

		internal IEnumerable<Type> GetAllGenericArguments()
		{
			return GetAllGenericArguments(Type);
		}

		private static IEnumerable<Type> GetAllGenericArguments(Type type)
		{
			Type[] genericArguments = type.GetGenericArguments();
			Type[] array = genericArguments;
			foreach (Type arg in array)
			{
				yield return arg;
				foreach (Type allGenericArgument in GetAllGenericArguments(arg))
				{
					yield return allGenericArgument;
				}
			}
		}

		public void CompileInPlace()
		{
			IProtoTypeSerializer serializer = Serializer;
			if (!(serializer is ICompiledSerializer) && !serializer.ExpectedType.IsEnum && model.TryGetRepeatedProvider(Type) == null)
			{
				ICompiledSerializer compiledSerializer = CompiledSerializer.Wrap(serializer, model);
				if (serializer != compiledSerializer)
				{
					_serializer = (IProtoTypeSerializer)compiledSerializer;
					Model.ResetServiceCache(Type);
				}
			}
		}

		internal bool IsDefined(int fieldNumber)
		{
			if (HasFields)
			{
				foreach (ValueMember field in Fields)
				{
					if (field.FieldNumber == fieldNumber)
					{
						return true;
					}
				}
			}
			return false;
		}

		private bool HasFlag(TypeOptions flag)
		{
			return (flags & flag) == flag;
		}

		private void SetFlag(TypeOptions flag, bool value, bool throwIfFrozen)
		{
			if (throwIfFrozen && HasFlag(flag) != value)
			{
				ThrowIfFrozen();
			}
			if (value)
			{
				flags |= flag;
			}
			else
			{
				flags &= (TypeOptions)(ushort)(~(int)flag);
			}
		}

		internal static MetaType GetRootType(MetaType source)
		{
			while (source._serializer != null)
			{
				MetaType metaType = source.baseType;
				if (metaType == null)
				{
					return source;
				}
				source = metaType;
			}
			RuntimeTypeModel runtimeTypeModel = source.model;
			int opaqueToken = 0;
			try
			{
				runtimeTypeModel.TakeLock(ref opaqueToken);
				MetaType metaType2;
				while ((metaType2 = source.baseType) != null)
				{
					source = metaType2;
				}
				return source;
			}
			finally
			{
				runtimeTypeModel.ReleaseLock(opaqueToken);
			}
		}

		internal bool IsPrepared()
		{
			return _serializer is CompiledSerializer;
		}

		internal static StringBuilder NewLine(StringBuilder builder, int indent)
		{
			return builder.AppendLine().Append(' ', indent * 3);
		}

		internal void WriteSchema(HashSet<Type> callstack, StringBuilder builder, int indent, HashSet<string> imports, ProtoSyntax syntax, string package, SchemaGenerationFlags flags)
		{
			if ((object)surrogateType != null)
			{
				return;
			}
			bool multipleNamespaceSupport = (flags & SchemaGenerationFlags.MultipleNamespaceSupport) != 0;
			RepeatedSerializerStub repeatedSerializerStub = model.TryGetRepeatedProvider(Type);
			if (repeatedSerializerStub != null)
			{
				NewLine(builder, indent).Append("message ").Append(GetSchemaTypeName(callstack)).Append(" {");
				if (repeatedSerializerStub.IsValidProtobufMap(model, CompatibilityLevel, DataFormat.Default))
				{
					repeatedSerializerStub.ResolveMapTypes(out var keyType, out var valueType);
					NewLine(builder, indent + 1).Append("map<").Append(model.GetSchemaTypeName(callstack, keyType, DataFormat.Default, CompatibilityLevel, asReference: false, dynamicType: false, imports)).Append(", ")
						.Append(model.GetSchemaTypeName(callstack, valueType, DataFormat.Default, CompatibilityLevel, asReference: false, dynamicType: false, imports))
						.Append("> items = 1;");
				}
				else
				{
					NewLine(builder, indent + 1).Append("repeated ").Append(model.GetSchemaTypeName(callstack, repeatedSerializerStub.ItemType, DataFormat.Default, CompatibilityLevel, asReference: false, dynamicType: false, imports)).Append(" items = 1;");
				}
				NewLine(builder, indent).Append('}');
				return;
			}
			if (IsAutoTuple)
			{
				if ((object)ResolveTupleConstructor(Type, out var mappedMembers) == null)
				{
					return;
				}
				NewLine(builder, indent).Append("message ").Append(GetSchemaTypeName(callstack)).Append(" {");
				AddNamespace(imports);
				for (int i = 0; i < mappedMembers.Length; i++)
				{
					Type effectiveType;
					if (mappedMembers[i] is PropertyInfo propertyInfo)
					{
						effectiveType = propertyInfo.PropertyType;
					}
					else
					{
						if (!(mappedMembers[i] is FieldInfo fieldInfo))
						{
							throw new NotSupportedException("Unknown member type: " + mappedMembers[i].GetType().Name);
						}
						effectiveType = fieldInfo.FieldType;
					}
					NewLine(builder, indent + 1).Append((syntax == ProtoSyntax.Proto2) ? "optional " : "").Append(model.GetSchemaTypeName(callstack, effectiveType, DataFormat.Default, CompatibilityLevel, asReference: false, dynamicType: false, imports)).Append(' ')
						.Append(mappedMembers[i].Name)
						.Append(" = ")
						.Append(i + 1)
						.Append(';');
				}
				NewLine(builder, indent).Append('}');
				return;
			}
			if (Type.IsEnum)
			{
				EnumMember[] enumValues = GetEnumValues();
				bool flag = IsValidEnum(enumValues);
				if (!flag)
				{
					NewLine(builder, indent).Append("/* for context only");
				}
				NewLine(builder, indent).Append("enum ").Append(GetSchemaTypeName(callstack)).Append(" {");
				AddNamespace(imports);
				if (Type.IsDefined(typeof(FlagsAttribute), inherit: true))
				{
					NewLine(builder, indent + 1).Append("// this is a composite/flags enumeration");
				}
				bool flag2 = false;
				HashSet<int> hashSet = new HashSet<int>();
				EnumMember[] array = enumValues;
				foreach (EnumMember enumMember in array)
				{
					int? num = enumMember.TryGetInt32();
					if (num.HasValue && !hashSet.Add(num.Value))
					{
						flag2 = true;
						break;
					}
				}
				if (flag2)
				{
					NewLine(builder, indent + 1).Append("option allow_alias = true;");
				}
				bool flag3 = false;
				EnumMember[] array2 = enumValues;
				for (int k = 0; k < array2.Length; k++)
				{
					EnumMember enumMember2 = array2[k];
					int? num2 = enumMember2.TryGetInt32();
					if (num2.HasValue && num2.Value == 0)
					{
						NewLine(builder, indent + 1).Append(enumMember2.Name).Append(" = 0;");
						flag3 = true;
					}
				}
				if (syntax == ProtoSyntax.Proto3 && !flag3)
				{
					NewLine(builder, indent + 1).Append("ZERO = 0; // proto3 requires a zero value as the first item (it can be named anything)");
				}
				EnumMember[] array3 = enumValues;
				for (int l = 0; l < array3.Length; l++)
				{
					EnumMember enumMember3 = array3[l];
					int? num3 = enumMember3.TryGetInt32();
					if (num3.HasValue)
					{
						if (num3.Value != 0)
						{
							NewLine(builder, indent + 1).Append(enumMember3.Name).Append(" = ").Append(num3.Value)
								.Append(';');
						}
					}
					else
					{
						NewLine(builder, indent + 1).Append("// ").Append(enumMember3.Name).Append(" = ")
							.Append(enumMember3.Value)
							.Append(';')
							.Append(" // note: enums should be valid 32-bit integers");
					}
				}
				if (HasReservations)
				{
					AppendReservations();
				}
				NewLine(builder, indent).Append('}');
				if (!flag)
				{
					NewLine(builder, indent).Append("*/");
				}
				return;
			}
			ExtraLayerValueMembers extraLayerValueMembers2 = new ExtraLayerValueMembers();
			ValueMember[] fields = GetFields();
			int length = builder.Length;
			NewLine(builder, indent).Append("message ").Append(GetSchemaTypeName(callstack)).Append(" {");
			AddNamespace(imports);
			ValueMember[] array4 = fields;
			foreach (ValueMember member in array4)
			{
				bool hasOption = false;
				string schemaTypeName2;
				string altName;
				if (member.IsMap)
				{
					if (member.NullWrappedCollection || member.NullWrappedValue)
					{
						throw new NotSupportedException("Schema generation for null-wrapped maps and maps with null-wrapped values is not currently implemented; poke @mgravell with a big stick if you need this!");
					}
					repeatedSerializerStub = model.TryGetRepeatedProvider(member.MemberType);
					repeatedSerializerStub.ResolveMapTypes(out var keyType2, out var valueType2);
					string schemaTypeName = model.GetSchemaTypeName(callstack, keyType2, member.MapKeyFormat, CompatibilityLevel, asReference: false, dynamicType: false, imports);
					schemaTypeName2 = model.GetSchemaTypeName(callstack, valueType2, member.MapValueFormat, CompatibilityLevel, member.AsReference, member.DynamicType, imports);
					NewLine(builder, indent + 1).Append("map<").Append(schemaTypeName).Append(',')
						.Append(schemaTypeName2)
						.Append("> ")
						.Append(member.Name)
						.Append(" = ")
						.Append(member.FieldNumber)
						.Append(';');
				}
				else if (member.RequiresExtraLayerInSchema())
				{
					schemaTypeName2 = member.GetSchemaTypeName(callstack, applyNetObjectProxy: true, imports, out altName);
					NullWrappedValueMemberData nullWrappedValueMemberData = extraLayerValueMembers2.Add(schemaTypeName2, member);
					WriteValueMember(nullWrappedValueMemberData.WrappedSchemaTypeName, nullWrappedValueMemberData.HasGroupModifier);
				}
				else
				{
					bool considerWrappersProtoTypes = member.HasExtendedNullSupport();
					schemaTypeName2 = member.GetSchemaTypeName(callstack, applyNetObjectProxy: true, imports, out altName, considerWrappersProtoTypes);
					WriteValueMember(schemaTypeName2, member.RequiresGroupModifier);
				}
				if (schemaTypeName2 == ".bcl.NetObjectProxy" && member.AsReference && !member.DynamicType)
				{
					builder.Append(" // reference-tracked ").Append(member.GetSchemaTypeName(callstack, applyNetObjectProxy: false, imports, out var _));
				}
				void WriteValueMember(string schemaModelTypeName, bool hasGroupModifier = false)
				{
					if (member.NullWrappedCollection)
					{
						throw new NotSupportedException("Schema generation for null-wrapped collections is not currently implemented; poke @mgravell with a big stick if you need this!");
					}
					string value2 = (((object)member.ItemType != null) ? "repeated " : ((syntax != 0) ? "" : (member.IsRequired ? "required " : "optional ")));
					NewLine(builder, indent + 1).Append(value2);
					if (hasGroupModifier)
					{
						builder.Append("group ");
					}
					else if (member.DataFormat == DataFormat.Group)
					{
						builder.Append("group ");
					}
					builder.Append(schemaModelTypeName).Append(' ').Append(member.Name)
						.Append(" = ")
						.Append(member.FieldNumber);
					if (syntax == ProtoSyntax.Proto2 && member.DefaultValue != null && !member.IsRequired)
					{
						if (member.DefaultValue is string)
						{
							AddOption(builder, ref hasOption).Append("default = \"").Append(member.DefaultValue).Append('"');
						}
						else if (!(member.DefaultValue is TimeSpan))
						{
							if (member.DefaultValue is bool flag4)
							{
								AddOption(builder, ref hasOption).Append(flag4 ? "default = true" : "default = false");
							}
							else
							{
								object defaultValue = member.DefaultValue;
								if (defaultValue is Enum && defaultValue.GetType() == member.MemberType && model.IsDefined(member.MemberType, member.CompatibilityLevel))
								{
									MetaType metaType = model[member.MemberType];
									foreach (EnumMember @enum in metaType.Enums)
									{
										if (!string.IsNullOrWhiteSpace(@enum.Name) && defaultValue.Equals(@enum.Value))
										{
											defaultValue = @enum.Name;
											break;
										}
									}
								}
								AddOption(builder, ref hasOption).Append("default = ").Append(member.DefaultValue);
							}
						}
					}
					if (CanPack(member.ItemType))
					{
						if (syntax == ProtoSyntax.Proto2)
						{
							if (member.IsPacked)
							{
								AddOption(builder, ref hasOption).Append("packed = true");
							}
						}
						else if (!member.IsPacked)
						{
							AddOption(builder, ref hasOption).Append("packed = false");
						}
					}
					if (member.AsReference)
					{
						imports.Add("protobuf-net/protogen.proto");
						AddOption(builder, ref hasOption).Append("(.protobuf_net.fieldopt).asRef = true");
					}
					if (member.DynamicType)
					{
						imports.Add("protobuf-net/protogen.proto");
						AddOption(builder, ref hasOption).Append("(.protobuf_net.fieldopt).dynamicType = true");
					}
					CloseOption(builder, ref hasOption).Append(';');
					if (syntax != 0 && member.DefaultValue != null && !member.IsRequired && !IsImplicitDefault(member.DefaultValue))
					{
						builder.Append(" // default value could not be applied: ").Append(member.DefaultValue);
					}
					if (!string.IsNullOrWhiteSpace(altName))
					{
						builder.Append(" // declared as invalid enum: ").Append(altName);
					}
				}
			}
			if (_subTypes != null && _subTypes.Count != 0)
			{
				SubType[] array5 = _subTypes.ToArray();
				Array.Sort(array5, SubType.Comparer.Default);
				string[] array6 = new string[array5.Length];
				for (int n = 0; n < array5.Length; n++)
				{
					array6[n] = array5[n].DerivedType.GetSchemaTypeName(callstack);
				}
				string text = "subtype";
				while (Array.IndexOf(array6, text) >= 0)
				{
					text = "_" + text;
				}
				NewLine(builder, indent + 1).Append("oneof ").Append(text).Append(" {");
				if ((flags & SchemaGenerationFlags.PreserveSubType) != 0)
				{
					imports.Add("protobuf-net/protogen.proto");
					NewLine(builder, indent + 2).Append("option (.protobuf_net.oneofopt).isSubType = true;");
				}
				for (int num4 = 0; num4 < array5.Length; num4++)
				{
					string value = array6[num4];
					NewLine(builder, indent + 2).Append(value).Append(' ').Append(value)
						.Append(" = ")
						.Append(array5[num4].FieldNumber)
						.Append(';');
				}
				NewLine(builder, indent + 1).Append('}');
			}
			if (HasReservations)
			{
				AppendReservations();
			}
			NewLine(builder, indent).Append('}');
			AddExtraLayerSchemaModels(extraLayerValueMembers2, length);
			void AddExtraLayerSchemaModels(ExtraLayerValueMembers extraLayerValueMembers, int pos)
			{
				if (extraLayerValueMembers.IsEmpty())
				{
					return;
				}
				foreach (NullWrappedValueMemberData extraLayerValueMember in extraLayerValueMembers)
				{
					NullWrappedValueMemberData wrappedValueMember = extraLayerValueMember;
					if (wrappedValueMember.HasSchemaTypeNameCollision)
					{
						builder.NewLine(ref pos, indent).Insert("// warning: duplicate message name; you can use [ProtoContract(Name = \"...\")] to supply an alternative schema name", ref pos);
					}
					builder.NewLine(ref pos, indent).Insert("message ", ref pos).Insert(wrappedValueMember.WrappedSchemaTypeName, ref pos)
						.Insert(" {", ref pos);
					builder.NewLine(ref pos, indent + 1);
					WriteWrappedFieldPayload();
					builder.Insert(";", ref pos);
					builder.NewLine(ref pos, indent).Insert("}", ref pos);
					void WriteWrappedFieldPayload()
					{
						builder.Insert("optional ", ref pos).Insert(wrappedValueMember.SchemaTypeName, ref pos).Insert(" value = 1", ref pos);
					}
				}
			}
			void AddNamespace(HashSet<string> imports)
			{
				if (multipleNamespaceSupport && !IsAutoTuple && !string.IsNullOrWhiteSpace(Type.Namespace) && !(Type.Namespace == package))
				{
					imports.Add("protobuf-net/protogen.proto");
					NewLine(builder, indent + 1).Append("option (.protobuf_net.");
					if (Type.IsEnum)
					{
						builder.Append("enumopt");
					}
					else
					{
						builder.Append("msgopt");
					}
					builder.Append(").namespace = \"" + Type.Namespace + "\";");
				}
			}
			void AppendReservations()
			{
				foreach (ProtoReservedAttribute reservation in _reservations)
				{
					NewLine(builder, indent + 1).Append("reserved ");
					if (reservation.From != 0)
					{
						builder.Append(reservation.From);
						if (reservation.To != reservation.From)
						{
							builder.Append(" to ").Append(reservation.To);
						}
					}
					else
					{
						builder.Append('"').Append(reservation.Name).Append('"');
					}
					builder.Append(';');
					if (!string.IsNullOrWhiteSpace(reservation.Comment))
					{
						builder.Append(" /* ").Append(reservation.Comment).Append(" */");
					}
				}
			}
		}

		private static StringBuilder AddOption(StringBuilder builder, ref bool hasOption)
		{
			if (hasOption)
			{
				return builder.Append(", ");
			}
			hasOption = true;
			return builder.Append(" [");
		}

		private static StringBuilder CloseOption(StringBuilder builder, ref bool hasOption)
		{
			if (hasOption)
			{
				hasOption = false;
				return builder.Append(']');
			}
			return builder;
		}

		private static bool IsImplicitDefault(object value)
		{
			try
			{
				if (value == null)
				{
					return false;
				}
				switch (Helpers.GetTypeCode(value.GetType()))
				{
				case ProtoTypeCode.Boolean:
					return !(bool)value;
				case ProtoTypeCode.Byte:
					return (byte)value == 0;
				case ProtoTypeCode.Char:
					return (char)value == '\0';
				case ProtoTypeCode.DateTime:
					return (DateTime)value == default(DateTime);
				case ProtoTypeCode.Decimal:
					return (decimal)value == 0m;
				case ProtoTypeCode.Double:
					return (double)value == 0.0;
				case ProtoTypeCode.Int16:
					return (short)value == 0;
				case ProtoTypeCode.Int32:
					return (int)value == 0;
				case ProtoTypeCode.Int64:
					return (long)value == 0;
				case ProtoTypeCode.SByte:
					return (sbyte)value == 0;
				case ProtoTypeCode.Single:
					return (float)value == 0f;
				case ProtoTypeCode.String:
					return value != null && ((string)value).Length == 0;
				case ProtoTypeCode.TimeSpan:
					return (TimeSpan)value == TimeSpan.Zero;
				case ProtoTypeCode.UInt16:
					return (ushort)value == 0;
				case ProtoTypeCode.UInt32:
					return (uint)value == 0;
				case ProtoTypeCode.UInt64:
					return (ulong)value == 0;
				case ProtoTypeCode.IntPtr:
					return (IntPtr)value == IntPtr.Zero;
				case ProtoTypeCode.UIntPtr:
					return (UIntPtr)value == UIntPtr.Zero;
				}
			}
			catch
			{
			}
			return false;
		}

		private static bool CanPack(Type type)
		{
			if ((object)type == null)
			{
				return false;
			}
			ProtoTypeCode typeCode = Helpers.GetTypeCode(type);
			if ((uint)(typeCode - 3) <= 11u)
			{
				return true;
			}
			return false;
		}

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Advanced)]
		public void ApplyFieldOffset(int offset)
		{
			if (Type.IsEnum)
			{
				throw new InvalidOperationException("Cannot apply field-offset to an enum");
			}
			if (offset == 0)
			{
				return;
			}
			int opaqueToken = 0;
			try
			{
				model.TakeLock(ref opaqueToken);
				ThrowIfFrozen();
				List<ValueMember> fields = _fields;
				List<SubType> subTypes = _subTypes;
				if (fields != null)
				{
					foreach (ValueMember item in fields)
					{
						AssertValidFieldNumber(item.FieldNumber + offset);
					}
				}
				if (subTypes != null)
				{
					foreach (SubType item2 in subTypes)
					{
						AssertValidFieldNumber(item2.FieldNumber + offset);
					}
				}
				if (fields != null)
				{
					foreach (ValueMember item3 in fields)
					{
						item3.FieldNumber += offset;
					}
				}
				if (subTypes == null)
				{
					return;
				}
				foreach (SubType item4 in subTypes)
				{
					item4.FieldNumber += offset;
				}
			}
			finally
			{
				model.ReleaseLock(opaqueToken);
			}
		}

		internal static void AssertValidFieldNumber(int fieldNumber)
		{
			if (fieldNumber < 1)
			{
				throw new ArgumentOutOfRangeException("fieldNumber");
			}
		}

		public MetaType AddReservation(int field, string comment = null)
		{
			return AddReservation(new ProtoReservedAttribute(field, comment));
		}

		public MetaType AddReservation(int from, int to, string comment = null)
		{
			return AddReservation(new ProtoReservedAttribute(from, to, comment));
		}

		public MetaType AddReservation(string field, string comment = null)
		{
			return AddReservation(new ProtoReservedAttribute(field, comment));
		}

		private MetaType AddReservation(ProtoReservedAttribute reservation)
		{
			reservation.Verify();
			int opaqueToken = 0;
			try
			{
				model.TakeLock(ref opaqueToken);
				ThrowIfFrozen();
				if (_reservations == null)
				{
					_reservations = new List<ProtoReservedAttribute>();
				}
				_reservations.Add(reservation);
			}
			finally
			{
				model.ReleaseLock(opaqueToken);
			}
			return this;
		}

		internal void Validate()
		{
			ValidateReservations();
		}

		internal void ValidateReservations()
		{
			if (!HasReservations || (!HasFields && !HasSubtypes && !HasEnums))
			{
				return;
			}
			foreach (ProtoReservedAttribute reservation in _reservations)
			{
				if (reservation.From != 0)
				{
					if (_fields != null)
					{
						foreach (ValueMember field in _fields)
						{
							if (field.FieldNumber >= reservation.From && field.FieldNumber <= reservation.To)
							{
								throw new InvalidOperationException($"Field {field.FieldNumber} is reserved and cannot be used for data member '{field.Name}'{CommentSuffix(reservation)}.");
							}
						}
					}
					if (_enums != null)
					{
						foreach (EnumMember @enum in _enums)
						{
							int? num = @enum.TryGetInt32();
							if (num.HasValue && num.Value >= reservation.From && num.Value <= reservation.To)
							{
								throw new InvalidOperationException($"Field {num.Value} is reserved and cannot be used for enum value '{@enum.Name}'{CommentSuffix(reservation)}.");
							}
						}
					}
					if (_subTypes == null)
					{
						continue;
					}
					foreach (SubType subType in _subTypes)
					{
						if (subType.FieldNumber >= reservation.From && subType.FieldNumber <= reservation.To)
						{
							throw new InvalidOperationException($"Field {subType.FieldNumber} is reserved and cannot be used for sub-type '{subType.DerivedType.Type.NormalizeName()}'{CommentSuffix(reservation)}.");
						}
					}
					continue;
				}
				if (_fields != null)
				{
					foreach (ValueMember field2 in _fields)
					{
						if (field2.Name == reservation.Name)
						{
							throw new InvalidOperationException($"Field '{field2.Name}' is reserved and cannot be used for data member {field2.FieldNumber}{CommentSuffix(reservation)}.");
						}
					}
				}
				if (_enums != null)
				{
					foreach (EnumMember enum2 in _enums)
					{
						if (enum2.Name == reservation.Name)
						{
							throw new InvalidOperationException($"Field '{enum2.Name}' is reserved and cannot be used for enum value {enum2.Value}{CommentSuffix(reservation)}.");
						}
					}
				}
				if (_subTypes == null)
				{
					continue;
				}
				foreach (SubType subType2 in _subTypes)
				{
					string text = subType2.DerivedType.Name;
					if (string.IsNullOrWhiteSpace(text))
					{
						text = subType2.DerivedType.Type.Name;
					}
					if (text == reservation.Name)
					{
						throw new InvalidOperationException($"Field '{text}' is reserved and cannot be used for sub-type {subType2.FieldNumber}{CommentSuffix(reservation)}.");
					}
				}
			}
			static string CommentSuffix(ProtoReservedAttribute reservation)
			{
				string comment = reservation.Comment;
				if (string.IsNullOrWhiteSpace(comment))
				{
					return "";
				}
				return " (" + comment.Trim() + ")";
			}
		}
	}
	internal class NullWrappedValueMemberData
	{
		private readonly string _originalSchemaTypeName;

		private readonly string _alternativeTypeName;

		private readonly bool _hasSchemaTypeNameCollision;

		private readonly ValueMember _valueMember;

		public string SchemaTypeName => _originalSchemaTypeName;

		public string WrappedSchemaTypeName
		{
			get
			{
				string text = ((!string.IsNullOrEmpty(_alternativeTypeName)) ? _alternativeTypeName : _originalSchemaTypeName);
				if (_valueMember.SupportNull)
				{
					return "WrappedAsSupportNull" + text;
				}
				if (_valueMember.NullWrappedValueGroup)
				{
					return "WrappedAsGroup" + text;
				}
				return "Wrapped" + text;
			}
		}

		public bool HasSchemaTypeNameCollision
		{
			get
			{
				if (_hasSchemaTypeNameCollision)
				{
					return !HasKnownTypeSchema();
				}
				return false;
			}
		}

		public Type ItemType => _valueMember.ItemType;

		public bool HasGroupModifier => _valueMember.RequiresGroupModifier;

		public NullWrappedValueMemberData(ValueMember valueMember, string originalSchemaTypeName, string alternativeTypeName = null, bool hasSchemaTypeNameCollision = false)
		{
			_originalSchemaTypeName = originalSchemaTypeName;
			_alternativeTypeName = alternativeTypeName;
			_hasSchemaTypeNameCollision = hasSchemaTypeNameCollision;
			_valueMember = valueMember;
		}

		private bool HasKnownTypeSchema()
		{
			switch (_originalSchemaTypeName)
			{
			case "int32":
			case "uint32":
			case "int64":
			case "uint64":
			case "double":
			case "bool":
			case "string":
				return true;
			default:
				return false;
			}
		}
	}
	internal sealed class RuntimeTypeModel : TypeModel
	{
		private enum RuntimeTypeModelOptions
		{
			None = 0,
			InternStrings = 1,
			IncludeDateTimeKind = 2,
			SkipZeroLengthPackedArrays = 4,
			AllowPackedEncodingAtRoot = 8,
			TypeModelMask = 15,
			InferTagFromNameDefault = 1024,
			IsDefaultModel = 2048,
			Frozen = 4096,
			AutoAddMissingTypes = 8192,
			AutoCompile = 16384,
			UseImplicitZeroDefaults = 32768,
			AllowParseableTypes = 65536,
			AutoAddProtoContractTypesOnly = 131072
		}

		internal static class CommonImports
		{
			public const string Bcl = "protobuf-net/bcl.proto";

			public const string WrappersProto = "google/protobuf/wrappers.proto";

			public const string Timestamp = "google/protobuf/timestamp.proto";

			public const string Duration = "google/protobuf/duration.proto";

			public const string Protogen = "protobuf-net/protogen.proto";

			public const string Empty = "google/protobuf/empty.proto";
		}

		private sealed class BasicType
		{
			public Type Type { get; }

			public IRuntimeProtoSerializerNode Serializer { get; }

			public BasicType(Type type, IRuntimeProtoSerializerNode serializer)
			{
				Type = type;
				Serializer = serializer;
			}
		}

		internal sealed class SerializerPair : IComparable
		{
			public readonly int MetaKey;

			public readonly int BaseKey;

			public readonly MetaType Type;

			public readonly MethodBuilder Serialize;

			public readonly MethodBuilder Deserialize;

			public readonly ILGenerator SerializeBody;

			public readonly ILGenerator DeserializeBody;

			int IComparable.CompareTo(object obj)
			{
				if (obj == null)
				{
					throw new ArgumentNullException("obj");
				}
				SerializerPair serializerPair = (SerializerPair)obj;
				int metaKey;
				if (BaseKey == MetaKey)
				{
					if (serializerPair.BaseKey == serializerPair.MetaKey)
					{
						metaKey = MetaKey;
						return metaKey.CompareTo(serializerPair.MetaKey);
					}
					return 1;
				}
				if (serializerPair.BaseKey == serializerPair.MetaKey)
				{
					return -1;
				}
				metaKey = BaseKey;
				int num = metaKey.CompareTo(serializerPair.BaseKey);
				if (num == 0)
				{
					metaKey = MetaKey;
					num = metaKey.CompareTo(serializerPair.MetaKey);
				}
				return num;
			}

			public SerializerPair(int metaKey, int baseKey, MetaType type, MethodBuilder serialize, MethodBuilder deserialize, ILGenerator serializeBody, ILGenerator deserializeBody)
			{
				MetaKey = metaKey;
				BaseKey = baseKey;
				Serialize = serialize;
				Deserialize = deserialize;
				SerializeBody = serializeBody;
				DeserializeBody = deserializeBody;
				Type = type;
			}
		}

		public sealed class CompilerOptions
		{
			public string TargetFrameworkName { get; set; }

			public string TargetFrameworkDisplayName { get; set; }

			public string TypeName { get; set; }

			public string OutputPath { get; set; }

			public string ImageRuntimeVersion { get; set; }

			public int MetaDataVersion { get; set; }

			public string AssemblyCompanyName { get; set; }

			public string AssemblyCopyright { get; set; }

			public string AssemblyDescription { get; set; }

			public string AssemblyProductName { get; set; }

			public string AssemblyTitle { get; set; }

			public string AssemblyTrademark { get; set; }

			public System.Version AssemblyVersion { get; set; }

			public System.Version AssemblyProductVersion { get; set; }

			public Accessibility Accessibility { get; set; }

			public event Func<Type, bool> IncludeType;

			public void SetFrameworkOptions(MetaType from)
			{
				if (from == null)
				{
					throw new ArgumentNullException("from");
				}
				AttributeMap[] array = AttributeMap.Create(from.Type.Assembly);
				AttributeMap[] array2 = array;
				foreach (AttributeMap attributeMap in array2)
				{
					if (attributeMap.AttributeType.FullName == "System.Runtime.Versioning.TargetFrameworkAttribute")
					{
						if (attributeMap.TryGet("FrameworkName", out var value))
						{
							TargetFrameworkName = (string)value;
						}
						if (attributeMap.TryGet("FrameworkDisplayName", out value))
						{
							TargetFrameworkDisplayName = (string)value;
						}
						break;
					}
				}
			}

			internal bool OnIncludeType(Type type)
			{
				return this.IncludeType?.Invoke(type) ?? true;
			}
		}

		public enum Accessibility
		{
			Public,
			Internal
		}

		private RuntimeTypeModelOptions _options;

		private CompatibilityLevel _defaultCompatibilityLevel = CompatibilityLevel.Level200;

		private static readonly BasicList.MatchPredicate BasicTypeFinder = (object value, object ctx) => ((BasicType)value).Type == (Type)ctx;

		private static readonly BasicList.MatchPredicate MetaTypeFinder = (object value, object ctx) => ((MetaType)value).Type == (Type)ctx;

		private readonly BasicList types = new BasicList();

		private readonly BasicList basicTypes = new BasicList();

		private readonly Hashtable _serviceCache = new Hashtable();

		private int metadataTimeoutMilliseconds = 5000;

		private int contentionCounter = 1;

		private MethodInfo defaultFactory;

		private readonly string _name;

		private static readonly object s_ModelSyncLock = new object();

		private Hashtable _externalProviders;

		public override TypeModelOptions Options => (TypeModelOptions)(_options & RuntimeTypeModelOptions.TypeModelMask);

		internal CompilerContextScope Scope { get; } = CompilerContextScope.CreateInProcess();


		public bool InferTagFromNameDefault
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.InferTagFromNameDefault);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.InferTagFromNameDefault, value);
			}
		}

		public bool AutoAddProtoContractTypesOnly
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.AutoAddProtoContractTypesOnly);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.AutoAddProtoContractTypesOnly, value);
			}
		}

		public bool UseImplicitZeroDefaults
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.UseImplicitZeroDefaults);
			}
			set
			{
				if (!value && GetOption(RuntimeTypeModelOptions.IsDefaultModel))
				{
					ThrowDefaultUseImplicitZeroDefaults();
				}
				SetOption(RuntimeTypeModelOptions.UseImplicitZeroDefaults, value);
			}
		}

		public bool AllowParseableTypes
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.AllowParseableTypes);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.AllowParseableTypes, value);
			}
		}

		public bool IncludeDateTimeKind
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.IncludeDateTimeKind);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.IncludeDateTimeKind, value);
			}
		}

		public bool SkipZeroLengthPackedArrays
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.SkipZeroLengthPackedArrays);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.SkipZeroLengthPackedArrays, value);
			}
		}

		public bool AllowPackedEncodingAtRoot
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.AllowPackedEncodingAtRoot);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.AllowPackedEncodingAtRoot, value);
			}
		}

		public bool InternStrings
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.InternStrings);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.InternStrings, value);
			}
		}

		public static RuntimeTypeModel Default => (TypeModel.DefaultModel as RuntimeTypeModel) ?? CreateDefaultModelInstance();

		public CompatibilityLevel DefaultCompatibilityLevel
		{
			get
			{
				return _defaultCompatibilityLevel;
			}
			set
			{
				if (value != _defaultCompatibilityLevel)
				{
					CompatibilityLevelAttribute.AssertValid(value);
					ThrowIfFrozen();
					if (GetOption(RuntimeTypeModelOptions.IsDefaultModel))
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The default compatibility level of the default model cannot be changed");
					}
					if (types.Any())
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The default compatibility level of cannot be changed once types have been added");
					}
					_defaultCompatibilityLevel = value;
				}
			}
		}

		public MetaType this[Type type] => (MetaType)types[FindOrAddAuto(type, demand: true, addWithContractOnly: false, addEvenIfAutoDisabled: false, DefaultCompatibilityLevel)];

		public bool AutoCompile
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.AutoCompile);
			}
			set
			{
				SetOption(RuntimeTypeModelOptions.AutoCompile, value);
			}
		}

		public bool AutoAddMissingTypes
		{
			get
			{
				return GetOption(RuntimeTypeModelOptions.AutoAddMissingTypes);
			}
			set
			{
				if (!value && GetOption(RuntimeTypeModelOptions.IsDefaultModel))
				{
					ThrowDefaultAutoAddMissingTypes();
				}
				ThrowIfFrozen();
				SetOption(RuntimeTypeModelOptions.AutoAddMissingTypes, value);
			}
		}

		public int MetadataTimeoutMilliseconds
		{
			get
			{
				return metadataTimeoutMilliseconds;
			}
			set
			{
				if (value <= 0)
				{
					throw new ArgumentOutOfRangeException("MetadataTimeoutMilliseconds");
				}
				metadataTimeoutMilliseconds = value;
			}
		}

		public event EventHandler<TypeAddedEventArgs> BeforeApplyDefaultBehaviour;

		public event EventHandler<TypeAddedEventArgs> AfterApplyDefaultBehaviour;

		public event LockContentedEventHandler LockContended;

		public static void Initialize()
		{
			_ = Default;
		}

		private bool GetOption(RuntimeTypeModelOptions option)
		{
			return (_options & option) != 0;
		}

		private void SetOption(RuntimeTypeModelOptions option, bool value)
		{
			if (value)
			{
				_options |= option;
			}
			else
			{
				_options &= ~option;
			}
		}

		public IEnumerable GetTypes()
		{
			return types;
		}

		public override string GetSchema(SchemaGenerationOptions options)
		{
			if (options == null)
			{
				throw new ArgumentNullException("options");
			}
			ProtoSyntax protoSyntax = Serializer.GlobalOptions.Normalize(options.Syntax);
			List<MetaType> requiredTypes = new List<MetaType>();
			List<Type> list = null;
			HashSet<Type> forceGenerationTypes = null;
			string package = options.Package;
			string origin = options.Origin;
			HashSet<string> imports = new HashSet<string>(StringComparer.Ordinal);
			if (!options.HasTypes && !options.HasServices)
			{
				BasicList.NodeEnumerator enumerator = types.GetEnumerator();
				while (enumerator.MoveNext())
				{
					MetaType metaType = (MetaType)enumerator.Current;
					MetaType surrogateOrBaseOrSelf = metaType.GetSurrogateOrBaseOrSelf(deep: false);
					AddMetaType(surrogateOrBaseOrSelf);
				}
			}
			else
			{
				if (options.HasTypes)
				{
					foreach (Type type3 in options.Types)
					{
						Type type2 = Nullable.GetUnderlyingType(type3) ?? type3;
						if (ValueMember.TryGetCoreSerializer(this, DataFormat.Default, DefaultCompatibilityLevel, type2, out var _, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false) != null)
						{
							(list ?? (list = new List<Type>())).Add(type2);
							continue;
						}
						bool flag = options.Types.Count == 1;
						MetaType metaType2 = AddType(type2, flag, flag);
					}
				}
				if (options.HasServices)
				{
					foreach (Service service in options.Services)
					{
						foreach (ServiceMethod method in service.Methods)
						{
							AddType(method.InputType, forceOutput: true, inferPackageAndOrigin: false);
							AddType(method.OutputType, forceOutput: true, inferPackageAndOrigin: false);
						}
					}
				}
			}
			StringBuilder stringBuilder = new StringBuilder();
			if (package == null)
			{
				IEnumerable<MetaType> enumerable;
				if (!options.HasTypes && !options.HasServices)
				{
					enumerable = types.Cast<MetaType>();
				}
				else
				{
					IEnumerable<MetaType> enumerable2 = requiredTypes;
					enumerable = enumerable2;
				}
				IEnumerable<MetaType> enumerable3 = enumerable;
				foreach (MetaType item in enumerable3)
				{
					if (TryGetRepeatedProvider(item.Type) != null)
					{
						continue;
					}
					string @namespace = item.Type.Namespace;
					if (!string.IsNullOrEmpty(@namespace) && !@namespace.StartsWith("System."))
					{
						if (package == null)
						{
							package = @namespace;
						}
						else if (!(package == @namespace))
						{
							package = null;
							break;
						}
					}
				}
			}
			switch (protoSyntax)
			{
			case ProtoSyntax.Proto2:
				stringBuilder.AppendLine("syntax = \"proto2\";");
				break;
			case ProtoSyntax.Proto3:
				stringBuilder.AppendLine("syntax = \"proto3\";");
				break;
			default:
				throw new ArgumentOutOfRangeException("syntax");
			}
			if (!string.IsNullOrEmpty(package))
			{
				stringBuilder.Append("package ").Append(package).Append(';')
					.AppendLine();
			}
			foreach (MetaType item2 in requiredTypes)
			{
				_ = item2.Serializer;
			}
			StringBuilder stringBuilder2 = new StringBuilder();
			HashSet<Type> callstack = new HashSet<Type>();
			MetaType[] array = new MetaType[requiredTypes.Count];
			requiredTypes.CopyTo(array, 0);
			Array.Sort(array, new MetaType.Comparer(callstack));
			if (list != null)
			{
				foreach (Type item3 in list)
				{
					stringBuilder2.AppendLine().Append("message ").Append(item3.Name)
						.Append(" {");
					MetaType.NewLine(stringBuilder2, 1).Append((protoSyntax == ProtoSyntax.Proto2) ? "optional " : "").Append(GetSchemaTypeName(callstack, item3, DataFormat.Default, DefaultCompatibilityLevel, asReference: false, dynamicType: false, imports))
						.Append(" value = 1;")
						.AppendLine()
						.Append('}');
				}
			}
			foreach (MetaType metaType3 in array)
			{
				if ((object)metaType3.SerializerType == null && (IsOutputForcedFor(metaType3.Type) || TryGetRepeatedProvider(metaType3.Type) == null))
				{
					metaType3.WriteSchema(callstack, stringBuilder2, 0, imports, protoSyntax, package, options.Flags);
				}
			}
			if (options.HasServices)
			{
				foreach (Service service2 in options.Services)
				{
					MetaType.NewLine(stringBuilder2, 0).Append("service ").Append(service2.Name)
						.Append(" {");
					foreach (ServiceMethod method2 in service2.Methods)
					{
						string schemaTypeName = GetSchemaTypeName(callstack, method2.InputType, DataFormat.Default, DefaultCompatibilityLevel, asReference: false, dynamicType: false, imports);
						string schemaTypeName2 = GetSchemaTypeName(callstack, method2.OutputType, DataFormat.Default, DefaultCompatibilityLevel, asReference: false, dynamicType: false, imports);
						MetaType.NewLine(stringBuilder2, 1).Append("rpc ").Append(method2.Name)
							.Append(" (")
							.Append(method2.ClientStreaming ? "stream " : "")
							.Append(schemaTypeName)
							.Append(") returns (")
							.Append(method2.ServerStreaming ? "stream " : "")
							.Append(schemaTypeName2)
							.Append(");");
					}
					MetaType.NewLine(stringBuilder2, 0).Append('}');
				}
			}
			foreach (string item4 in imports.OrderBy((string _) => _))
			{
				if (string.IsNullOrWhiteSpace(item4))
				{
					continue;
				}
				stringBuilder.Append("import \"").Append(item4).Append("\";");
				if (!(item4 == "protobuf-net/bcl.proto"))
				{
					if (item4 == "protobuf-net/protogen.proto")
					{
						stringBuilder.Append(" // custom protobuf-net options");
					}
				}
				else
				{
					stringBuilder.Append(" // schema for protobuf-net's handling of core .NET types");
				}
				stringBuilder.AppendLine();
			}
			return stringBuilder.Append((object?)stringBuilder2).AppendLine().ToString();
			void AddMetaType(MetaType toAdd)
			{
				if (!string.IsNullOrWhiteSpace(toAdd.Origin) && toAdd.Origin != origin)
				{
					imports.Add(toAdd.Origin);
				}
				else if (!requiredTypes.Contains(toAdd))
				{
					requiredTypes.Add(toAdd);
					CascadeDependents(requiredTypes, toAdd, imports, origin);
				}
			}
			MetaType AddType(Type type, bool forceOutput, bool inferPackageAndOrigin)
			{
				if (forceOutput && (object)type != null)
				{
					(forceGenerationTypes ?? (forceGenerationTypes = new HashSet<Type>())).Add(type);
				}
				int num = FindOrAddAuto(type, demand: false, addWithContractOnly: false, addEvenIfAutoDisabled: false, DefaultCompatibilityLevel);
				if (num < 0)
				{
					throw new ArgumentException("The type specified is not a contract-type: '" + type.NormalizeName() + "'", "type");
				}
				MetaType surrogateOrBaseOrSelf2 = ((MetaType)types[num]).GetSurrogateOrBaseOrSelf(deep: false);
				if (inferPackageAndOrigin)
				{
					if (origin == null && !string.IsNullOrWhiteSpace(surrogateOrBaseOrSelf2.Origin))
					{
						origin = surrogateOrBaseOrSelf2.Origin;
					}
					string text;
					if (package == null && !string.IsNullOrWhiteSpace(text = surrogateOrBaseOrSelf2.GuessPackage()))
					{
						package = text;
					}
				}
				AddMetaType(surrogateOrBaseOrSelf2);
				return surrogateOrBaseOrSelf2;
			}
			bool IsOutputForcedFor(Type type)
			{
				return forceGenerationTypes?.Contains(type) ?? false;
			}
		}

		private void CascadeRepeated(List<MetaType> list, RepeatedSerializerStub provider, CompatibilityLevel ambient, DataFormat keyFormat, HashSet<string> imports, string origin)
		{
			if (provider.IsMap)
			{
				provider.ResolveMapTypes(out var keyType, out var valueType);
				TryGetCoreSerializer(list, keyType, ambient, imports, origin);
				TryGetCoreSerializer(list, valueType, ambient, imports, origin);
				if (!provider.IsValidProtobufMap(this, ambient, keyFormat))
				{
					TryGetCoreSerializer(list, provider.ItemType, ambient, imports, origin);
				}
			}
			else
			{
				TryGetCoreSerializer(list, provider.ItemType, ambient, imports, origin);
			}
		}

		private void CascadeDependents(List<MetaType> list, MetaType metaType, HashSet<string> imports, string origin)
		{
			RepeatedSerializerStub repeatedSerializerStub = TryGetRepeatedProvider(metaType.Type);
			if (repeatedSerializerStub != null)
			{
				CascadeRepeated(list, repeatedSerializerStub, metaType.CompatibilityLevel, DataFormat.Default, imports, origin);
				return;
			}
			if (metaType.IsAutoTuple)
			{
				if ((object)MetaType.ResolveTupleConstructor(metaType.Type, out var mappedMembers) != null)
				{
					for (int i = 0; i < mappedMembers.Length; i++)
					{
						Type itemType = null;
						if (mappedMembers[i] is PropertyInfo propertyInfo)
						{
							itemType = propertyInfo.PropertyType;
						}
						else if (mappedMembers[i] is FieldInfo fieldInfo)
						{
							itemType = fieldInfo.FieldType;
						}
						TryGetCoreSerializer(list, itemType, metaType.CompatibilityLevel, imports, origin);
					}
				}
			}
			else
			{
				foreach (ValueMember field in metaType.Fields)
				{
					repeatedSerializerStub = TryGetRepeatedProvider(field.MemberType);
					if (repeatedSerializerStub != null)
					{
						CascadeRepeated(list, repeatedSerializerStub, field.CompatibilityLevel, field.MapKeyFormat, imports, origin);
						if (repeatedSerializerStub.IsMap && !field.IsMap)
						{
							TryGetCoreSerializer(list, repeatedSerializerStub.ItemType, field.CompatibilityLevel, imports, origin);
						}
					}
					else
					{
						TryGetCoreSerializer(list, field.MemberType, field.CompatibilityLevel, imports, origin);
					}
				}
			}
			foreach (Type allGenericArgument in metaType.GetAllGenericArguments())
			{
				repeatedSerializerStub = TryGetRepeatedProvider(allGenericArgument);
				if (repeatedSerializerStub != null)
				{
					CascadeRepeated(list, repeatedSerializerStub, metaType.CompatibilityLevel, DataFormat.Default, imports, origin);
				}
				else
				{
					TryGetCoreSerializer(list, allGenericArgument, metaType.CompatibilityLevel, imports, origin);
				}
			}
			MetaType surrogateOrSelf;
			if (metaType.HasSubtypes)
			{
				SubType[] subtypes = metaType.GetSubtypes();
				foreach (SubType subType in subtypes)
				{
					surrogateOrSelf = subType.DerivedType.GetSurrogateOrSelf();
					if (!list.Contains(surrogateOrSelf))
					{
						list.Add(surrogateOrSelf);
						CascadeDependents(list, surrogateOrSelf, imports, origin);
					}
				}
			}
			surrogateOrSelf = metaType.BaseType;
			if (surrogateOrSelf != null)
			{
				surrogateOrSelf = surrogateOrSelf.GetSurrogateOrSelf();
			}
			if (surrogateOrSelf != null && !list.Contains(surrogateOrSelf))
			{
				list.Add(surrogateOrSelf);
				CascadeDependents(list, surrogateOrSelf, imports, origin);
			}
		}

		private void TryGetCoreSerializer(List<MetaType> list, Type itemType, CompatibilityLevel ambient, HashSet<string> imports, string origin)
		{
			IRuntimeProtoSerializerNode runtimeProtoSerializerNode = ValueMember.TryGetCoreSerializer(this, DataFormat.Default, CompatibilityLevel.NotSpecified, itemType, out var defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false);
			if (runtimeProtoSerializerNode != null)
			{
				return;
			}
			int num = FindOrAddAuto(itemType, demand: false, addWithContractOnly: false, addEvenIfAutoDisabled: false, ambient);
			if (num < 0)
			{
				return;
			}
			MetaType metaType = (MetaType)types[num];
			if (metaType.HasSurrogate)
			{
				runtimeProtoSerializerNode = ValueMember.TryGetCoreSerializer(this, metaType.surrogateDataFormat, metaType.CompatibilityLevel, metaType.surrogateType, out defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false);
				if (runtimeProtoSerializerNode != null)
				{
					return;
				}
			}
			MetaType surrogateOrBaseOrSelf = metaType.GetSurrogateOrBaseOrSelf(deep: false);
			if (!string.IsNullOrWhiteSpace(surrogateOrBaseOrSelf.Origin) && surrogateOrBaseOrSelf.Origin != origin)
			{
				imports.Add(surrogateOrBaseOrSelf.Origin);
			}
			else if (!list.Contains(surrogateOrBaseOrSelf))
			{
				list.Add(surrogateOrBaseOrSelf);
				CascadeDependents(list, surrogateOrBaseOrSelf, imports, origin);
			}
		}

		internal RuntimeTypeModel(bool isDefault, string name)
		{
			AutoAddMissingTypes = true;
			UseImplicitZeroDefaults = true;
			SetOption(RuntimeTypeModelOptions.IsDefaultModel, isDefault);
			try
			{
				AutoCompile = EnableAutoCompile();
			}
			catch
			{
			}
			if (!string.IsNullOrWhiteSpace(name))
			{
				_name = name;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static bool EnableAutoCompile()
		{
			try
			{
				DynamicMethod dynamicMethod = new DynamicMethod("CheckCompilerAvailable", typeof(bool), new Type[1] { typeof(int) });
				ILGenerator iLGenerator = dynamicMethod.GetILGenerator();
				iLGenerator.Emit(OpCodes.Ldarg_0);
				iLGenerator.Emit(OpCodes.Ldc_I4, 42);
				iLGenerator.Emit(OpCodes.Ceq);
				iLGenerator.Emit(OpCodes.Ret);
				Predicate<int> predicate = (Predicate<int>)dynamicMethod.CreateDelegate(typeof(Predicate<int>));
				return predicate(42);
			}
			catch (Exception)
			{
				return false;
			}
		}

		internal MetaType FindWithAmbientCompatibility(Type type, CompatibilityLevel ambient)
		{
			MetaType metaType = (MetaType)types[FindOrAddAuto(type, demand: true, addWithContractOnly: false, addEvenIfAutoDisabled: false, ambient)];
			if (metaType != null && metaType.IsAutoTuple && metaType.CompatibilityLevel != ambient)
			{
				throw new InvalidOperationException($"The tuple-like type {type.NormalizeName()} must use a single compatiblity level, but '{ambient}' and '{metaType.CompatibilityLevel}' are both observed; this usually means it is being used in different contexts in the same model.");
			}
			return metaType;
		}

		internal MetaType FindWithoutAdd(Type type)
		{
			type = DynamicStub.GetEffectiveType(type);
			BasicList.NodeEnumerator enumerator = types.GetEnumerator();
			while (enumerator.MoveNext())
			{
				MetaType metaType = (MetaType)enumerator.Current;
				if (metaType.Type == type)
				{
					if (metaType.Pending)
					{
						WaitOnLock();
					}
					return metaType;
				}
			}
			return null;
		}

		private void WaitOnLock()
		{
			int opaqueToken = 0;
			try
			{
				TakeLock(ref opaqueToken);
			}
			finally
			{
				ReleaseLock(opaqueToken);
			}
		}

		internal IRuntimeProtoSerializerNode TryGetBasicTypeSerializer(Type type)
		{
			int num = basicTypes.IndexOf(BasicTypeFinder, type);
			if (num >= 0)
			{
				return ((BasicType)basicTypes[num]).Serializer;
			}
			lock (basicTypes)
			{
				num = basicTypes.IndexOf(BasicTypeFinder, type);
				if (num >= 0)
				{
					return ((BasicType)basicTypes[num]).Serializer;
				}
				WireType defaultWireType;
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode = ((MetaType.GetContractFamily(this, type, null) == MetaType.AttributeFamily.None) ? ValueMember.TryGetCoreSerializer(this, DataFormat.Default, CompatibilityLevel.NotSpecified, type, out defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false) : null);
				if (runtimeProtoSerializerNode != null)
				{
					basicTypes.Add(new BasicType(type, runtimeProtoSerializerNode));
				}
				return runtimeProtoSerializerNode;
			}
		}

		internal int FindOrAddAuto(Type type, bool demand, bool addWithContractOnly, bool addEvenIfAutoDisabled, CompatibilityLevel ambient)
		{
			type = DynamicStub.GetEffectiveType(type);
			int num = types.IndexOf(MetaTypeFinder, type);
			if (num >= 0)
			{
				MetaType metaType = (MetaType)types[num];
				if (metaType.Pending)
				{
					WaitOnLock();
				}
				return num;
			}
			bool flag = AutoAddMissingTypes || addEvenIfAutoDisabled;
			if (!type.IsEnum && TryGetBasicTypeSerializer(type) != null)
			{
				if (flag && !addWithContractOnly)
				{
					throw MetaType.InbuiltType(type);
				}
				return -1;
			}
			if (num < 0)
			{
				int opaqueToken = 0;
				bool flag2 = false;
				try
				{
					TakeLock(ref opaqueToken);
					MetaType metaType;
					if ((metaType = RecogniseCommonTypes(type)) == null)
					{
						MetaType.AttributeFamily contractFamily = MetaType.GetContractFamily(this, type, null);
						if (contractFamily == MetaType.AttributeFamily.AutoTuple)
						{
							flag = (addEvenIfAutoDisabled = true);
						}
						if (!flag || (!type.IsEnum && addWithContractOnly && contractFamily == MetaType.AttributeFamily.None))
						{
							if (demand)
							{
								TypeModel.ThrowUnexpectedType(type, this);
							}
							return num;
						}
						metaType = Create(type);
					}
					metaType.Pending = true;
					int num2 = types.IndexOf(MetaTypeFinder, type);
					if (num2 < 0)
					{
						ThrowIfFrozen();
						num = types.Add(metaType);
						flag2 = true;
					}
					else
					{
						num = num2;
					}
					if (flag2)
					{
						metaType.ApplyDefaultBehaviour(ambient);
						metaType.Pending = false;
					}
				}
				finally
				{
					ReleaseLock(opaqueToken);
				}
			}
			return num;
		}

		private MetaType RecogniseCommonTypes(Type type)
		{
			return null;
		}

		private MetaType Create(Type type)
		{
			ThrowIfFrozen();
			return new MetaType(this, type, defaultFactory);
		}

		public MetaType Add<T>(bool applyDefaultBehaviour = true, CompatibilityLevel compatibilityLevel = CompatibilityLevel.NotSpecified)
		{
			return Add(typeof(T), applyDefaultBehaviour, compatibilityLevel);
		}

		public MetaType Add(Type type, bool applyDefaultBehaviour)
		{
			return Add(type, applyDefaultBehaviour, CompatibilityLevel.NotSpecified);
		}

		public MetaType Add(Type type, bool applyDefaultBehaviour = true, CompatibilityLevel compatibilityLevel = CompatibilityLevel.NotSpecified)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			if (type == typeof(object))
			{
				throw new ArgumentException("You cannot reconfigure " + type.FullName);
			}
			type = DynamicStub.GetEffectiveType(type);
			MetaType metaType = FindWithoutAdd(type);
			if (metaType != null)
			{
				if (compatibilityLevel != 0)
				{
					metaType.Assert(compatibilityLevel);
				}
				return metaType;
			}
			int opaqueToken = 0;
			try
			{
				metaType = RecogniseCommonTypes(type);
				if (metaType != null)
				{
					if (!applyDefaultBehaviour)
					{
						throw new ArgumentException("Default behaviour must be observed for certain types with special handling; " + type.FullName, "applyDefaultBehaviour");
					}
					applyDefaultBehaviour = false;
				}
				if (metaType == null)
				{
					metaType = Create(type);
				}
				metaType.CompatibilityLevel = compatibilityLevel;
				metaType.Pending = true;
				TakeLock(ref opaqueToken);
				if (FindWithoutAdd(type) != null)
				{
					throw new ArgumentException("Duplicate type", "type");
				}
				ThrowIfFrozen();
				types.Add(metaType);
				if (applyDefaultBehaviour)
				{
					metaType.ApplyDefaultBehaviour(CompatibilityLevel.NotSpecified);
				}
				metaType.Pending = false;
				return metaType;
			}
			finally
			{
				ReleaseLock(opaqueToken);
			}
		}

		internal static void OnBeforeApplyDefaultBehaviour(MetaType metaType, ref TypeAddedEventArgs args)
		{
			OnApplyDefaultBehaviour(metaType?.Model?.BeforeApplyDefaultBehaviour, metaType, ref args);
		}

		internal static void OnAfterApplyDefaultBehaviour(MetaType metaType, ref TypeAddedEventArgs args)
		{
			OnApplyDefaultBehaviour(metaType?.Model?.AfterApplyDefaultBehaviour, metaType, ref args);
		}

		private static void OnApplyDefaultBehaviour(EventHandler<TypeAddedEventArgs> handler, MetaType metaType, ref TypeAddedEventArgs args)
		{
			if (handler != null)
			{
				if (args == null)
				{
					args = new TypeAddedEventArgs(metaType);
				}
				handler(metaType.Model, args);
			}
		}

		private void ThrowIfFrozen()
		{
			if (GetOption(RuntimeTypeModelOptions.Frozen))
			{
				throw new InvalidOperationException("The model cannot be changed once frozen");
			}
		}

		public void Freeze()
		{
			if (GetOption(RuntimeTypeModelOptions.IsDefaultModel))
			{
				ThrowDefaultFrozen();
			}
			SetOption(RuntimeTypeModelOptions.Frozen, value: true);
		}

		protected override ISerializer<T> GetSerializer<T>()
		{
			return GetServices<T>(CompatibilityLevel.NotSpecified) as ISerializer<T>;
		}

		internal override ISerializer<T> GetSerializerCore<T>(CompatibilityLevel ambient)
		{
			return GetServices<T>(ambient) as ISerializer<T>;
		}

		internal override bool IsKnownType<T>(CompatibilityLevel ambient)
		{
			if (_serviceCache[typeof(T)] == null)
			{
				return FindOrAddAuto(typeof(T), demand: false, addWithContractOnly: true, addEvenIfAutoDisabled: false, ambient) >= 0;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private object GetServices<T>(CompatibilityLevel ambient)
		{
			return _serviceCache[typeof(T)] ?? GetServicesSlow(typeof(T), ambient);
		}

		internal void ResetServiceCache(Type type)
		{
			if ((object)type != null)
			{
				lock (_serviceCache)
				{
					_serviceCache.Remove(type);
				}
			}
		}

		private object GetServicesSlow(Type type, CompatibilityLevel ambient)
		{
			if ((object)type == null)
			{
				return null;
			}
			object obj;
			lock (_serviceCache)
			{
				obj = _serviceCache[type];
				if (obj != null)
				{
					return obj;
				}
			}
			obj = GetServicesImpl(this, type, ambient);
			if (obj != null)
			{
				try
				{
					_ = this[type];
				}
				catch
				{
				}
				lock (_serviceCache)
				{
					_serviceCache[type] = obj;
				}
			}
			return obj;
			static object GetServicesImpl(RuntimeTypeModel model, Type type, CompatibilityLevel ambient)
			{
				if (type.IsEnum)
				{
					return EnumSerializers.GetSerializer(type);
				}
				Type underlyingType = Nullable.GetUnderlyingType(type);
				if ((object)underlyingType != null)
				{
					return model.GetServicesSlow(underlyingType, ambient);
				}
				RepeatedSerializerStub repeatedSerializerStub = model.TryGetRepeatedProvider(type);
				if (repeatedSerializerStub != null)
				{
					return repeatedSerializerStub.Serializer;
				}
				int num = model.FindOrAddAuto(type, demand: false, addWithContractOnly: true, addEvenIfAutoDisabled: false, ambient);
				if (num >= 0)
				{
					MetaType metaType = (MetaType)model.types[num];
					IProtoTypeSerializer serializer = metaType.Serializer;
					if (serializer is IExternalSerializer externalSerializer)
					{
						return externalSerializer.Service;
					}
					return serializer;
				}
				return null;
			}
		}

		public override string ToString()
		{
			return _name ?? base.ToString();
		}

		internal ProtoSerializer<TActual> GetSerializer<TActual>(IRuntimeProtoSerializerNode serializer, bool compiled)
		{
			if (serializer == null)
			{
				throw new ArgumentNullException("serializer");
			}
			if (compiled)
			{
				return CompilerContext.BuildSerializer<TActual>(Scope, serializer, this);
			}
			return delegate(ref ProtoWriter.State state, TActual val)
			{
				serializer.Write(ref state, val);
			};
		}

		public void CompileInPlace()
		{
			BasicList.NodeEnumerator enumerator = types.GetEnumerator();
			while (enumerator.MoveNext())
			{
				MetaType metaType = (MetaType)enumerator.Current;
				metaType.CompileInPlace();
			}
		}

		private void BuildAllSerializers()
		{
			for (int i = 0; i < types.Count; i++)
			{
				MetaType metaType = (MetaType)types[i];
				if (GetServicesSlow(metaType.Type, metaType.CompatibilityLevel) == null)
				{
					throw new InvalidOperationException("No serializer available for " + metaType.Type.NormalizeName());
				}
			}
		}

		internal static ILGenerator Override(TypeBuilder type, string name)
		{
			Type[] genericArgs;
			return Override(type, name, out genericArgs);
		}

		internal static ILGenerator Override(TypeBuilder type, string name, out Type[] genericArgs)
		{
			MethodInfo method;
			try
			{
				method = type.BaseType.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if ((object)method == null)
				{
					throw new ArgumentException("Unable to resolve '" + name + "'");
				}
			}
			catch (Exception ex)
			{
				throw new ArgumentException("Unable to resolve '" + name + "': " + ex.Message, "name", ex);
			}
			ParameterInfo[] parameters = method.GetParameters();
			Type[] array = new Type[parameters.Length];
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = parameters[i].ParameterType;
			}
			MethodBuilder methodBuilder = type.DefineMethod(method.Name, (method.Attributes & ~(MethodAttributes.VtableLayoutMask | MethodAttributes.Abstract)) | MethodAttributes.Final, method.CallingConvention, method.ReturnType, array);
			if (method.IsGenericMethodDefinition)
			{
				genericArgs = method.GetGenericArguments();
				string[] names = Array.ConvertAll(genericArgs, (Type x) => x.Name);
				methodBuilder.DefineGenericParameters(names);
			}
			else
			{
				genericArgs = Type.EmptyTypes;
			}
			for (int j = 0; j < parameters.Length; j++)
			{
				methodBuilder.DefineParameter(j + 1, parameters[j].Attributes, parameters[j].Name);
			}
			ILGenerator iLGenerator = methodBuilder.GetILGenerator();
			type.DefineMethodOverride(methodBuilder, method);
			return iLGenerator;
		}

		public TypeModel Compile(string name, string path)
		{
			CompilerOptions options = new CompilerOptions
			{
				TypeName = name,
				OutputPath = path
			};
			return Compile(options);
		}

		public TypeModel Compile(CompilerOptions options = null)
		{
			if (options == null)
			{
				options = new CompilerOptions();
			}
			string text = options.TypeName;
			string outputPath = options.OutputPath;
			BuildAllSerializers();
			Freeze();
			bool flag = !string.IsNullOrEmpty(outputPath);
			if (string.IsNullOrEmpty(text))
			{
				if (flag)
				{
					throw new ArgumentNullException("typeName");
				}
				text = "CompiledModel_" + Guid.NewGuid();
			}
			string text2;
			string text3;
			if (outputPath == null)
			{
				text2 = text;
				text3 = text2 + ".dll";
			}
			else
			{
				text2 = new FileInfo(Path.GetFileNameWithoutExtension(outputPath)).Name;
				text3 = text2 + Path.GetExtension(outputPath);
			}
			AssemblyName assemblyName = new AssemblyName
			{
				Name = text2,
				Version = options.AssemblyVersion
			};
			AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, flag ? ((AssemblyBuilderAccess)3) : AssemblyBuilderAccess.RunAndCollect);
			ModuleBuilder module = (flag ? assemblyBuilder.DefineDynamicModule(text3, outputPath) : assemblyBuilder.DefineDynamicModule(text3));
			CompilerContextScope scope = CompilerContextScope.CreateForModule(this, module, isFullEmit: true, text2);
			WriteAssemblyAttributes(options, text2, assemblyBuilder);
			TypeBuilder typeBuilder = WriteBasicTypeModel("<Services>" + text, module, typeof(object), @internal: true);
			WriteSerializers(scope, typeBuilder);
			WriteEnumsAndProxies(typeBuilder);
			Type serviceType = typeBuilder.CreateType();
			TypeBuilder typeBuilder2 = WriteBasicTypeModel(text, module, typeof(TypeModel), options.Accessibility == Accessibility.Internal);
			WriteConstructorsAndOverrides(typeBuilder2, serviceType);
			Type type = typeBuilder2.CreateType();
			if (!string.IsNullOrEmpty(outputPath))
			{
				try
				{
					assemblyBuilder.Save(outputPath);
				}
				catch (IOException ex)
				{
					throw new IOException(outputPath + ", " + ex.Message, ex);
				}
			}
			return (TypeModel)Activator.CreateInstance(type, nonPublic: true);
		}

		private void WriteConstructorsAndOverrides(TypeBuilder type, Type serviceType)
		{
			TypeModelOptions options = Options;
			ILGenerator iLGenerator;
			if (options != 0)
			{
				iLGenerator = Override(type, "get_Options");
				CompilerContext.LoadValue(iLGenerator, (int)options);
				iLGenerator.Emit(OpCodes.Ret);
			}
			iLGenerator = Override(type, "GetSerializer", out var genericArgs);
			Type type2 = genericArgs.Single();
			MethodInfo methodInfo = typeof(SerializerCache).GetMethod("Get").MakeGenericMethod(serviceType, type2);
			iLGenerator.EmitCall(OpCodes.Call, methodInfo, null);
			iLGenerator.Emit(OpCodes.Ret);
			type.DefineDefaultConstructor(MethodAttributes.Public);
		}

		private void WriteEnumsAndProxies(TypeBuilder type)
		{
			for (int i = 0; i < types.Count; i++)
			{
				MetaType metaType = (MetaType)types[i];
				Type type2 = metaType.Type;
				RepeatedSerializerStub repeatedSerializerStub;
				if (type2.IsEnum)
				{
					MemberInfo provider = EnumSerializers.GetProvider(type2);
					AddProxy(type, type2, provider, includeNullable: true);
				}
				else if (ShouldEmitCustomSerializerProxy(metaType.SerializerType))
				{
					AddProxy(type, type2, metaType.SerializerType, includeNullable: false);
				}
				else if ((repeatedSerializerStub = TryGetRepeatedProvider(type2)) != null)
				{
					AddProxy(type, type2, repeatedSerializerStub.Provider, includeNullable: false);
				}
			}
			static bool ShouldEmitCustomSerializerProxy(Type serializerType)
			{
				if ((object)serializerType == null)
				{
					return false;
				}
				if (IsFullyPublic(serializerType))
				{
					return true;
				}
				return serializerType.Assembly != typeof(PrimaryTypeProvider).Assembly;
			}
		}

		internal static MemberInfo GetUnderlyingProvider(MemberInfo provider, Type forType)
		{
			MemberInfo memberInfo = provider;
			if (!(memberInfo is PropertyInfo propertyInfo))
			{
				if (memberInfo is Type type && type.IsClass && !type.IsAbstract && (object)type.GetConstructor(Type.EmptyTypes) != null)
				{
					provider = typeof(SerializerCache).GetMethod("Get", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(type, forType);
				}
			}
			else
			{
				provider = propertyInfo.GetGetMethod(nonPublic: true);
			}
			return provider;
		}

		internal static void EmitProvider(MemberInfo provider, ILGenerator il)
		{
			if (!(provider is FieldInfo fieldInfo))
			{
				if (provider is MethodInfo methodInfo && methodInfo.IsStatic)
				{
					il.EmitCall(OpCodes.Call, methodInfo, null);
					return;
				}
			}
			else if (fieldInfo.IsStatic)
			{
				il.Emit(OpCodes.Ldsfld, fieldInfo);
				return;
			}
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Invalid provider: {provider}");
		}

		internal RepeatedSerializerStub TryGetRepeatedProvider(Type type, CompatibilityLevel ambient = CompatibilityLevel.NotSpecified)
		{
			if ((object)type == null)
			{
				return null;
			}
			RepeatedSerializerStub repeatedSerializerStub = RepeatedSerializers.TryGetRepeatedProvider(type, _externalProviders);
			if (repeatedSerializerStub != null)
			{
				int num = FindOrAddAuto(type, demand: false, addWithContractOnly: true, addEvenIfAutoDisabled: false, ambient);
				if (num >= 0 && ((MetaType)types[num]).IgnoreListHandling)
				{
					return null;
				}
			}
			return repeatedSerializerStub;
		}

		private static void AddProxy(TypeBuilder building, Type proxying, MemberInfo provider, bool includeNullable)
		{
			provider = GetUnderlyingProvider(provider, proxying);
			if ((object)provider != null)
			{
				Type interfaceType = typeof(ISerializerProxy<>).MakeGenericType(proxying);
				building.AddInterfaceImplementation(interfaceType);
				ILGenerator iLGenerator = CompilerContextScope.Implement(building, interfaceType, "get_Serializer");
				EmitProvider(provider, iLGenerator);
				iLGenerator.Emit(OpCodes.Ret);
				if (includeNullable)
				{
					interfaceType = typeof(ISerializerProxy<>).MakeGenericType(typeof(Nullable<>).MakeGenericType(proxying));
					building.AddInterfaceImplementation(interfaceType);
					iLGenerator = CompilerContextScope.Implement(building, interfaceType, "get_Serializer");
					EmitProvider(provider, iLGenerator);
					iLGenerator.Emit(OpCodes.Ret);
				}
			}
		}

		private void WriteSerializers(CompilerContextScope scope, TypeBuilder type)
		{
			Dictionary<SerializerFeatures, MethodInfo> featuresLookup = new Dictionary<SerializerFeatures, MethodInfo>();
			for (int i = 0; i < types.Count; i++)
			{
				MetaType metaType = (MetaType)types[i];
				IProtoTypeSerializer serializer = metaType.Serializer;
				Type type2 = metaType.Type;
				metaType.Validate();
				if (type2.IsEnum || (object)metaType.SerializerType != null || TryGetRepeatedProvider(metaType.Type) != null)
				{
					continue;
				}
				if (!IsFullyPublic(type2, out var cause))
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Non-public type cannot be used with full dll compilation: " + cause.NormalizeName());
				}
				Type inheritanceRoot = metaType.GetInheritanceRoot();
				Type type3 = typeof(ISerializer<>).MakeGenericType(type2);
				type.AddInterfaceImplementation(type3);
				ILGenerator il = CompilerContextScope.Implement(type, type3, "Read");
				using (CompilerContext compilerContext = new CompilerContext(scope, il, isStatic: false, CompilerContext.SignatureType.ReaderScope_Input, this, type2, "Read"))
				{
					if (serializer.HasInheritance)
					{
						serializer.EmitReadRoot(compilerContext, compilerContext.InputValue);
					}
					else
					{
						serializer.EmitRead(compilerContext, compilerContext.InputValue);
						compilerContext.LoadValue(compilerContext.InputValue);
					}
					compilerContext.Return();
				}
				il = CompilerContextScope.Implement(type, type3, "Write");
				using (CompilerContext compilerContext2 = new CompilerContext(scope, il, isStatic: false, CompilerContext.SignatureType.WriterScope_Input, this, type2, "Write"))
				{
					if (serializer.HasInheritance)
					{
						serializer.EmitWriteRoot(compilerContext2, compilerContext2.InputValue);
					}
					else
					{
						serializer.EmitWrite(compilerContext2, compilerContext2.InputValue);
					}
					compilerContext2.Return();
				}
				MethodInfo getMethod = type3.GetProperty("Features").GetGetMethod();
				type.DefineMethodOverride(GetFeaturesMethod(serializer.Features), getMethod);
				if (serializer.HasInheritance)
				{
					type3 = typeof(ISubTypeSerializer<>).MakeGenericType(type2);
					type.AddInterfaceImplementation(type3);
					il = CompilerContextScope.Implement(type, type3, "WriteSubType");
					using (CompilerContext compilerContext3 = new CompilerContext(scope, il, isStatic: false, CompilerContext.SignatureType.WriterScope_Input, this, type2, "WriteSubType"))
					{
						serializer.EmitWrite(compilerContext3, compilerContext3.InputValue);
						compilerContext3.Return();
					}
					il = CompilerContextScope.Implement(type, type3, "ReadSubType");
					using CompilerContext compilerContext4 = new CompilerContext(scope, il, isStatic: false, CompilerContext.SignatureType.ReaderScope_Input, this, typeof(SubTypeState<>).MakeGenericType(type2), "ReadSubType");
					serializer.EmitRead(compilerContext4, compilerContext4.InputValue);
					compilerContext4.Return();
				}
				if (serializer.ShouldEmitCreateInstance)
				{
					type3 = typeof(IFactory<>).MakeGenericType(type2);
					type.AddInterfaceImplementation(type3);
					il = CompilerContextScope.Implement(type, type3, "Create");
					using CompilerContext compilerContext5 = new CompilerContext(scope, il, isStatic: false, CompilerContext.SignatureType.Context, this, typeof(ISerializationContext), "Create");
					serializer.EmitCreateInstance(compilerContext5, callNoteObject: false);
					compilerContext5.Return();
				}
			}
			MethodInfo GetFeaturesMethod(SerializerFeatures features)
			{
				if (!featuresLookup.TryGetValue(features, out var value))
				{
					int num = (int)features;
					string name = "Features_" + num.ToString(CultureInfo.InvariantCulture);
					MethodBuilder methodBuilder = type.DefineMethod(name, MethodAttributes.Private | MethodAttributes.Virtual, typeof(SerializerFeatures), Type.EmptyTypes);
					ILGenerator iLGenerator = methodBuilder.GetILGenerator();
					CompilerContext.LoadValue(iLGenerator, (int)features);
					iLGenerator.Emit(OpCodes.Ret);
					return featuresLookup[features] = methodBuilder;
				}
				return value;
			}
		}

		private static TypeBuilder WriteBasicTypeModel(string typeName, ModuleBuilder module, Type baseType, bool @internal)
		{
			TypeAttributes typeAttributes = (baseType.Attributes & ~(TypeAttributes.Abstract | TypeAttributes.Serializable)) | TypeAttributes.Sealed;
			if (@internal)
			{
				typeAttributes &= ~TypeAttributes.Public;
			}
			return module.DefineType(typeName, typeAttributes, baseType);
		}

		private void WriteAssemblyAttributes(CompilerOptions options, string assemblyName, AssemblyBuilder asm)
		{
			if (!string.IsNullOrEmpty(options.TargetFrameworkName))
			{
				Type type = null;
				try
				{
					type = TypeModel.ResolveKnownType("System.Runtime.Versioning.TargetFrameworkAttribute", typeof(string).Assembly);
				}
				catch
				{
				}
				if ((object)type != null)
				{
					PropertyInfo[] namedProperties;
					object[] propertyValues;
					if (string.IsNullOrEmpty(options.TargetFrameworkDisplayName))
					{
						namedProperties = Array.Empty<PropertyInfo>();
						propertyValues = Array.Empty<object>();
					}
					else
					{
						namedProperties = new PropertyInfo[1] { type.GetProperty("FrameworkDisplayName") };
						propertyValues = new object[1] { options.TargetFrameworkDisplayName };
					}
					CustomAttributeBuilder customAttribute = new CustomAttributeBuilder(type.GetConstructor(new Type[1] { typeof(string) }), new object[1] { options.TargetFrameworkName }, namedProperties, propertyValues);
					asm.SetCustomAttribute(customAttribute);
				}
			}
			Type type2 = null;
			try
			{
				type2 = typeof(InternalsVisibleToAttribute);
			}
			catch
			{
			}
			if ((object)type2 != null)
			{
				List<string> list = new List<string>();
				List<Assembly> list2 = new List<Assembly>();
				BasicList.NodeEnumerator enumerator = types.GetEnumerator();
				while (enumerator.MoveNext())
				{
					MetaType metaType = (MetaType)enumerator.Current;
					Assembly assembly = metaType.Type.Assembly;
					if (list2.IndexOf(assembly) >= 0)
					{
						continue;
					}
					list2.Add(assembly);
					AttributeMap[] array = AttributeMap.Create(assembly);
					for (int i = 0; i < array.Length; i++)
					{
						if (!(array[i].AttributeType != type2))
						{
							array[i].TryGet("AssemblyName", out var value2);
							string text = value2 as string;
							if (!(text == assemblyName) && !string.IsNullOrEmpty(text) && list.IndexOf(text) < 0)
							{
								list.Add(text);
								CustomAttributeBuilder customAttribute2 = new CustomAttributeBuilder(type2.GetConstructor(new Type[1] { typeof(string) }), new object[1] { text });
								asm.SetCustomAttribute(customAttribute2);
							}
						}
					}
				}
			}
			WriteAssemblyInfoAttributes(options, asm);
			static void WriteAssemblyInfoAttribute<TAttribute>(CompilerOptions options, AssemblyBuilder asm, string value) where TAttribute : Attribute
			{
				if (!string.IsNullOrEmpty(value))
				{
					Type typeFromHandle = typeof(TAttribute);
					Type[] array2 = new Type[1] { typeof(string) };
					ConstructorInfo constructor = typeFromHandle.GetConstructor(array2);
					CustomAttributeBuilder customAttribute3 = new CustomAttributeBuilder(constructor, new object[1] { value });
					asm.SetCustomAttribute(customAttribute3);
				}
			}
			static void WriteAssemblyInfoAttributes(CompilerOptions options, AssemblyBuilder asm)
			{
				WriteAssemblyInfoAttribute<AssemblyFileVersionAttribute>(options, asm, options.AssemblyVersion?.ToString());
				WriteAssemblyInfoAttribute<AssemblyCompanyAttribute>(options, asm, options.AssemblyCompanyName);
				WriteAssemblyInfoAttribute<AssemblyCopyrightAttribute>(options, asm, options.AssemblyCopyright);
				WriteAssemblyInfoAttribute<AssemblyDescriptionAttribute>(options, asm, options.AssemblyDescription);
				WriteAssemblyInfoAttribute<AssemblyProductAttribute>(options, asm, options.AssemblyProductName);
				WriteAssemblyInfoAttribute<AssemblyTitleAttribute>(options, asm, options.AssemblyTitle);
				WriteAssemblyInfoAttribute<AssemblyTrademarkAttribute>(options, asm, options.AssemblyTrademark);
				WriteAssemblyInfoAttribute<AssemblyInformationalVersionAttribute>(options, asm, options.AssemblyProductVersion?.ToString());
				asm.DefineVersionInfoResource();
			}
		}

		internal bool IsPrepared(Type type)
		{
			return FindWithoutAdd(type)?.IsPrepared() ?? false;
		}

		internal void TakeLock(ref int opaqueToken)
		{
			opaqueToken = 0;
			if (Monitor.TryEnter(types, metadataTimeoutMilliseconds))
			{
				opaqueToken = GetContention();
				return;
			}
			AddContention();
			throw new TimeoutException("Timeout while inspecting metadata; this may indicate a deadlock. This can often be avoided by preparing necessary serializers during application initialization, rather than allowing multiple threads to perform the initial metadata inspection; please also see the LockContended event");
		}

		private int GetContention()
		{
			return Interlocked.CompareExchange(ref contentionCounter, 0, 0);
		}

		private void AddContention()
		{
			Interlocked.Increment(ref contentionCounter);
		}

		internal void ReleaseLock(int opaqueToken)
		{
			if (opaqueToken == 0)
			{
				return;
			}
			Monitor.Exit(types);
			if (opaqueToken == GetContention())
			{
				return;
			}
			LockContentedEventHandler lockContended = this.LockContended;
			if (lockContended != null)
			{
				string stackTrace;
				try
				{
					throw new ProtoException();
				}
				catch (Exception ex)
				{
					stackTrace = ex.StackTrace;
				}
				lockContended(this, new LockContentedEventArgs(stackTrace));
			}
		}

		internal string GetSchemaTypeName(HashSet<Type> callstack, Type effectiveType, DataFormat dataFormat, CompatibilityLevel compatibilityLevel, bool asReference, bool dynamicType, HashSet<string> imports)
		{
			string altName;
			return GetSchemaTypeName(callstack, effectiveType, dataFormat, compatibilityLevel, asReference, dynamicType, imports, out altName);
		}

		private static bool IsWrappersProtoType(Type type, out string name, HashSet<string> imports)
		{
			name = null;
			if (type == typeof(double?))
			{
				name = ".google.protobuf.DoubleValue";
			}
			if (type == typeof(float?))
			{
				name = ".google.protobuf.FloatValue";
			}
			if (type == typeof(long?))
			{
				name = ".google.protobuf.Int64Value";
			}
			if (type == typeof(ulong?))
			{
				name = ".google.protobuf.UInt64Value";
			}
			if (type == typeof(int?))
			{
				name = ".google.protobuf.Int32Value";
			}
			if (type == typeof(uint?))
			{
				name = ".google.protobuf.UInt32Value";
			}
			if (type == typeof(bool?))
			{
				name = ".google.protobuf.BoolValue";
			}
			if (type == typeof(string))
			{
				name = ".google.protobuf.StringValue";
			}
			if (type == typeof(byte[]))
			{
				name = ".google.protobuf.BytesValue";
			}
			if (name == null)
			{
				return false;
			}
			imports.Add("google/protobuf/wrappers.proto");
			return true;
		}

		private static bool IsWellKnownType(Type type, out string name, HashSet<string> imports)
		{
			if (TypeHelper.IsBytesLike(type))
			{
				name = "bytes";
				return true;
			}
			if (type == typeof(Timestamp))
			{
				imports.Add("google/protobuf/timestamp.proto");
				name = ".google.protobuf.Timestamp";
				return true;
			}
			if (type == typeof(Duration))
			{
				imports.Add("google/protobuf/duration.proto");
				name = ".google.protobuf.Duration";
				return true;
			}
			if (type == typeof(Empty))
			{
				imports.Add("google/protobuf/empty.proto");
				name = ".google.protobuf.Empty";
				return true;
			}
			name = null;
			return false;
		}

		internal string GetSchemaTypeName(HashSet<Type> callstack, Type effectiveType, DataFormat dataFormat, CompatibilityLevel compatibilityLevel, bool asReference, bool dynamicType, HashSet<string> imports, out string altName, bool considerWrappersProtoTypes = false)
		{
			altName = null;
			if (considerWrappersProtoTypes && IsWrappersProtoType(effectiveType, out var name, imports))
			{
				return name;
			}
			compatibilityLevel = ValueMember.GetEffectiveCompatibilityLevel(compatibilityLevel, dataFormat);
			effectiveType = DynamicStub.GetEffectiveType(effectiveType);
			if (IsWellKnownType(effectiveType, out var name2, imports))
			{
				return name2;
			}
			WireType defaultWireType;
			IRuntimeProtoSerializerNode runtimeProtoSerializerNode = ValueMember.TryGetCoreSerializer(this, dataFormat, compatibilityLevel, effectiveType, out defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false);
			if (runtimeProtoSerializerNode == null)
			{
				if (asReference || dynamicType)
				{
					imports.Add("protobuf-net/bcl.proto");
					return ".bcl.NetObjectProxy";
				}
				MetaType metaType = this[effectiveType];
				if (metaType.HasSurrogate && ValueMember.TryGetCoreSerializer(this, metaType.surrogateDataFormat, metaType.CompatibilityLevel, metaType.surrogateType, out defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false) != null)
				{
					return GetSchemaTypeName(callstack, metaType.surrogateType, metaType.surrogateDataFormat, metaType.CompatibilityLevel, asReference: false, dynamicType: false, imports);
				}
				MetaType surrogateOrBaseOrSelf = metaType.GetSurrogateOrBaseOrSelf(deep: true);
				if (IsWellKnownType(surrogateOrBaseOrSelf.Type, out name2, imports))
				{
					return name2;
				}
				string schemaTypeName = surrogateOrBaseOrSelf.GetSchemaTypeName(callstack);
				if (metaType.Type.IsEnum && !metaType.IsValidEnum())
				{
					altName = schemaTypeName;
					schemaTypeName = GetSchemaTypeName(callstack, Enum.GetUnderlyingType(metaType.Type), dataFormat, CompatibilityLevel.NotSpecified, asReference, dynamicType, imports);
				}
				return schemaTypeName;
			}
			if (runtimeProtoSerializerNode is ParseableSerializer)
			{
				if (asReference)
				{
					imports.Add("protobuf-net/bcl.proto");
				}
				if (!asReference)
				{
					return "string";
				}
				return ".bcl.NetObjectProxy";
			}
			switch (Helpers.GetTypeCode(effectiveType))
			{
			case ProtoTypeCode.Boolean:
				return "bool";
			case ProtoTypeCode.Single:
				return "float";
			case ProtoTypeCode.Double:
				return "double";
			case ProtoTypeCode.String:
				if (asReference)
				{
					imports.Add("protobuf-net/bcl.proto");
				}
				if (!asReference)
				{
					return "string";
				}
				return ".bcl.NetObjectProxy";
			case ProtoTypeCode.Char:
			case ProtoTypeCode.Byte:
			case ProtoTypeCode.UInt16:
			case ProtoTypeCode.UInt32:
				if (dataFormat == DataFormat.FixedSize)
				{
					return "fixed32";
				}
				return "uint32";
			case ProtoTypeCode.SByte:
			case ProtoTypeCode.Int16:
			case ProtoTypeCode.Int32:
				return dataFormat switch
				{
					DataFormat.ZigZag => "sint32", 
					DataFormat.FixedSize => "sfixed32", 
					_ => "int32", 
				};
			case ProtoTypeCode.UInt64:
			case ProtoTypeCode.UIntPtr:
				if (dataFormat == DataFormat.FixedSize)
				{
					return "fixed64";
				}
				return "uint64";
			case ProtoTypeCode.Int64:
			case ProtoTypeCode.IntPtr:
				return dataFormat switch
				{
					DataFormat.ZigZag => "sint64", 
					DataFormat.FixedSize => "sfixed64", 
					_ => "int64", 
				};
			case ProtoTypeCode.DateTime:
				if (dataFormat == DataFormat.FixedSize)
				{
					return "sint64";
				}
				if (compatibilityLevel >= CompatibilityLevel.Level240)
				{
					imports.Add("google/protobuf/timestamp.proto");
					return ".google.protobuf.Timestamp";
				}
				imports.Add("protobuf-net/bcl.proto");
				return ".bcl.DateTime";
			case ProtoTypeCode.TimeSpan:
				if (dataFormat == DataFormat.FixedSize)
				{
					return "sint64";
				}
				if (compatibilityLevel >= CompatibilityLevel.Level240)
				{
					imports.Add("google/protobuf/duration.proto");
					return ".google.protobuf.Duration";
				}
				imports.Add("protobuf-net/bcl.proto");
				return ".bcl.TimeSpan";
			case ProtoTypeCode.Decimal:
				if (compatibilityLevel < CompatibilityLevel.Level300)
				{
					imports.Add("protobuf-net/bcl.proto");
					return ".bcl.Decimal";
				}
				return "string";
			case ProtoTypeCode.Guid:
				if (compatibilityLevel < CompatibilityLevel.Level300)
				{
					imports.Add("protobuf-net/bcl.proto");
					return ".bcl.Guid";
				}
				if (dataFormat != DataFormat.FixedSize)
				{
					return "string";
				}
				return "bytes";
			case ProtoTypeCode.Type:
				return "string";
			case ProtoTypeCode.Uri:
				return "string";
			default:
				throw new NotSupportedException("No .proto map found for: " + effectiveType.FullName);
			}
		}

		public void SetDefaultFactory(MethodInfo methodInfo)
		{
			VerifyFactory(methodInfo, null);
			defaultFactory = methodInfo;
		}

		internal static void VerifyFactory(MethodInfo factory, Type type)
		{
			if ((object)factory != null)
			{
				if ((object)type != null && type.IsValueType)
				{
					throw new InvalidOperationException();
				}
				if (!factory.IsStatic)
				{
					throw new ArgumentException("A factory-method must be static", "factory");
				}
				if ((object)type != null && factory.ReturnType != type && factory.ReturnType != typeof(object))
				{
					throw new ArgumentException("The factory-method must return object" + (((object)type == null) ? "" : (" or " + type.FullName)), "factory");
				}
				if (!CallbackSet.CheckCallbackParameters(factory))
				{
					throw new ArgumentException("Invalid factory signature in " + factory.DeclaringType.FullName + "." + factory.Name, "factory");
				}
			}
		}

		public static RuntimeTypeModel Create([CallerMemberName] string name = null)
		{
			return new RuntimeTypeModel(isDefault: false, name);
		}

		internal static bool IsFullyPublic(Type type)
		{
			Type cause;
			return IsFullyPublic(type, out cause);
		}

		internal static bool IsFullyPublic(Type type, out Type cause)
		{
			Type type2 = type;
			while ((object)type != null)
			{
				if (type.IsGenericType)
				{
					Type[] genericArguments = type.GetGenericArguments();
					Type[] array = genericArguments;
					foreach (Type type3 in array)
					{
						if (!IsFullyPublic(type3))
						{
							cause = type3;
							return false;
						}
					}
				}
				cause = type;
				if (type.IsNestedPublic)
				{
					type = type.DeclaringType;
					continue;
				}
				return type.IsPublic;
			}
			cause = type2;
			return false;
		}

		public new static TypeModel CreateForAssembly<T>()
		{
			return AutoCompileTypeModel.CreateForAssembly<T>();
		}

		public new static TypeModel CreateForAssembly(Type type)
		{
			return AutoCompileTypeModel.CreateForAssembly(type);
		}

		public new static TypeModel CreateForAssembly(Assembly assembly)
		{
			return AutoCompileTypeModel.CreateForAssembly(assembly);
		}

		public void MakeDefault()
		{
			lock (s_ModelSyncLock)
			{
				RuntimeTypeModel runtimeTypeModel = TypeModel.DefaultModel as RuntimeTypeModel;
				if (this == runtimeTypeModel)
				{
					return;
				}
				try
				{
					SetOption(RuntimeTypeModelOptions.IsDefaultModel, value: true);
					if (!UseImplicitZeroDefaults)
					{
						ThrowDefaultUseImplicitZeroDefaults();
					}
					if (!AutoAddMissingTypes)
					{
						ThrowDefaultAutoAddMissingTypes();
					}
					if (GetOption(RuntimeTypeModelOptions.Frozen))
					{
						ThrowDefaultFrozen();
					}
					TypeModel.SetDefaultModel(this);
				}
				finally
				{
					TypeModel defaultModel = TypeModel.DefaultModel;
					if (this != defaultModel)
					{
						SetOption(RuntimeTypeModelOptions.IsDefaultModel, value: false);
					}
					if (runtimeTypeModel != null && runtimeTypeModel != defaultModel)
					{
						runtimeTypeModel.SetOption(RuntimeTypeModelOptions.IsDefaultModel, value: false);
					}
				}
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowDefaultAutoAddMissingTypes()
		{
			throw new InvalidOperationException("The default model must allow missing types");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowDefaultUseImplicitZeroDefaults()
		{
			throw new InvalidOperationException("UseImplicitZeroDefaults cannot be disabled on the default model");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowDefaultFrozen()
		{
			throw new InvalidOperationException("The default model cannot be frozen");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static RuntimeTypeModel CreateDefaultModelInstance()
		{
			lock (s_ModelSyncLock)
			{
				RuntimeTypeModel runtimeTypeModel = TypeModel.DefaultModel as RuntimeTypeModel;
				if (runtimeTypeModel == null)
				{
					runtimeTypeModel = new RuntimeTypeModel(isDefault: true, "(default)");
					TypeModel.SetDefaultModel(runtimeTypeModel);
				}
				return runtimeTypeModel;
			}
		}

		public RuntimeTypeModel SetSurrogate<TUnderlying, TSurrogate>(Func<TUnderlying, TSurrogate> underlyingToSurrogate = null, Func<TSurrogate, TUnderlying> surrogateToUnderlying = null, DataFormat dataFormat = DataFormat.Default, CompatibilityLevel compatibilityLevel = CompatibilityLevel.NotSpecified)
		{
			Add<TUnderlying>(applyDefaultBehaviour: true, compatibilityLevel).SetSurrogate(typeof(TSurrogate), GetMethod(underlyingToSurrogate, "underlyingToSurrogate"), GetMethod(surrogateToUnderlying, "surrogateToUnderlying"), dataFormat);
			return this;
			static MethodInfo GetMethod(Delegate value, string paramName)
			{
				if ((object)value == null)
				{
					return null;
				}
				Delegate[] invocationList = value.GetInvocationList();
				if (invocationList.Length != 1)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("A unicast delegate was expected.", paramName);
				}
				value = invocationList[0];
				object target = value.Target;
				if (target != null)
				{
					string text = "A delegate to a static method was expected.";
					if (target.GetType().IsDefined(typeof(CompilerGeneratedAttribute)))
					{
						text = text + " The conversion '" + target.GetType().NormalizeName() + "." + value.Method.Name + "' is compiler-generated (possibly a lambda); an explicit static method should be used instead.";
					}
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentException(text, paramName);
				}
				return value.Method;
			}
		}

		public RuntimeTypeModel AddSerializer(Type collectionType, Type serializerType)
		{
			Type type = collectionType;
			if (type.IsGenericType)
			{
				type = type.GetGenericTypeDefinition();
			}
			lock (_serviceCache)
			{
				if (_externalProviders == null)
				{
					_externalProviders = new Hashtable();
				}
			}
			if (!_externalProviders.ContainsKey(type))
			{
				RepeatedSerializers.Add(type, (Type root, Type current, Type[] targs) => RepeatedSerializers.Resolve(serializerType, "Create", targs), exactOnly: true, _externalProviders);
			}
			return this;
		}
	}
	internal sealed class LockContentedEventArgs : EventArgs
	{
		public string OwnerStackTrace { get; }

		internal LockContentedEventArgs(string ownerStackTrace)
		{
			OwnerStackTrace = ownerStackTrace;
		}
	}
	internal delegate void LockContentedEventHandler(object sender, LockContentedEventArgs args);
	internal sealed class SubType
	{
		internal sealed class Comparer : IComparer, IComparer<SubType>
		{
			public static readonly Comparer Default = new Comparer();

			public int Compare(object x, object y)
			{
				return Compare(x as SubType, y as SubType);
			}

			public int Compare(SubType x, SubType y)
			{
				if (x == y)
				{
					return 0;
				}
				if (x == null)
				{
					return -1;
				}
				if (y == null)
				{
					return 1;
				}
				return x.FieldNumber.CompareTo(y.FieldNumber);
			}
		}

		private int _fieldNumber;

		private readonly MetaType derivedType;

		private readonly DataFormat dataFormat;

		private IRuntimeProtoSerializerNode serializer;

		public int FieldNumber
		{
			get
			{
				return _fieldNumber;
			}
			internal set
			{
				if (_fieldNumber != value)
				{
					MetaType.AssertValidFieldNumber(value);
					ThrowIfFrozen();
					_fieldNumber = value;
				}
			}
		}

		public MetaType DerivedType => derivedType;

		private void ThrowIfFrozen()
		{
			if (serializer != null)
			{
				throw new InvalidOperationException("The type cannot be changed once a serializer has been generated");
			}
		}

		public SubType(int fieldNumber, MetaType derivedType, DataFormat format)
		{
			if (fieldNumber <= 0)
			{
				throw new ArgumentOutOfRangeException("fieldNumber");
			}
			_fieldNumber = fieldNumber;
			this.derivedType = derivedType ?? throw new ArgumentNullException("derivedType");
			dataFormat = format;
		}

		internal IRuntimeProtoSerializerNode GetSerializer(Type parentType)
		{
			return serializer ?? (serializer = BuildSerializer(parentType));
		}

		private IRuntimeProtoSerializerNode BuildSerializer(Type parentType)
		{
			WireType wireType = WireType.String;
			if (dataFormat == DataFormat.Group)
			{
				wireType = WireType.StartGroup;
			}
			IRuntimeProtoSerializerNode tail = SubItemSerializer.Create(derivedType.Type, derivedType, parentType);
			return new TagDecorator(_fieldNumber, wireType, strict: false, tail);
		}
	}
	internal sealed class TypeAddedEventArgs : EventArgs
	{
		public bool ApplyDefaultBehaviour { get; set; }

		public MetaType MetaType { get; }

		public Type Type => MetaType.Type;

		public RuntimeTypeModel Model => MetaType.Model;

		internal TypeAddedEventArgs(MetaType metaType)
		{
			MetaType = metaType;
			ApplyDefaultBehaviour = true;
		}
	}
	internal class ValueMember
	{
		internal sealed class Comparer : IComparer, IComparer<ValueMember>
		{
			public static readonly Comparer Default = new Comparer();

			public int Compare(object x, object y)
			{
				return Compare(x as ValueMember, y as ValueMember);
			}

			public int Compare(ValueMember x, ValueMember y)
			{
				if (x == y)
				{
					return 0;
				}
				if (x == null)
				{
					return -1;
				}
				if (y == null)
				{
					return 1;
				}
				return x.FieldNumber.CompareTo(y.FieldNumber);
			}
		}

		private int _fieldNumber;

		private MemberInfo backingMember;

		private object _defaultValue;

		private CompatibilityLevel _compatibilityLevel;

		private readonly RuntimeTypeModel model;

		private IRuntimeProtoSerializerNode serializer;

		private DataFormat dataFormat;

		private DataFormat mapKeyFormat;

		private DataFormat mapValueFormat;

		private MethodInfo getSpecified;

		private MethodInfo setSpecified;

		private string name;

		private const ushort OPTIONS_IsStrict = 1;

		private const ushort OPTIONS_IsPacked = 2;

		private const ushort OPTIONS_IsRequired = 4;

		private const ushort OPTIONS_OverwriteList = 8;

		private const ushort OPTIONS_NullWrappedValue = 16;

		private const ushort OPTIONS_NullWrappedValueGroup = 32;

		private const ushort OPTIONS_IsMap = 64;

		private const ushort OPTIONS_NullWrappedCollection = 128;

		private const ushort OPTIONS_NullWrappedCollectionGroup = 256;

		private const ushort OPTIONS_SupportNull = 512;

		private ushort flags;

		public int FieldNumber
		{
			get
			{
				return _fieldNumber;
			}
			internal set
			{
				if (_fieldNumber != value)
				{
					MetaType.AssertValidFieldNumber(value);
					ThrowIfFrozen();
					_fieldNumber = value;
				}
			}
		}

		public MemberInfo Member { get; }

		public MemberInfo BackingMember
		{
			get
			{
				return backingMember;
			}
			set
			{
				if (backingMember != value)
				{
					ThrowIfFrozen();
					backingMember = value;
				}
			}
		}

		public Type ItemType { get; }

		public Type MemberType { get; }

		public Type DefaultType { get; }

		public Type ParentType { get; }

		public object DefaultValue
		{
			get
			{
				return _defaultValue;
			}
			set
			{
				if (_defaultValue != value)
				{
					ThrowIfFrozen();
					_defaultValue = value;
				}
			}
		}

		public CompatibilityLevel CompatibilityLevel
		{
			get
			{
				return _compatibilityLevel;
			}
			set
			{
				if (_compatibilityLevel != value)
				{
					ThrowIfFrozen();
					CompatibilityLevelAttribute.AssertValid(value);
					_compatibilityLevel = value;
				}
			}
		}

		internal IRuntimeProtoSerializerNode Serializer => serializer ?? (serializer = BuildSerializer());

		public DataFormat DataFormat
		{
			get
			{
				return dataFormat;
			}
			set
			{
				if (value != dataFormat)
				{
					ThrowIfFrozen();
					dataFormat = value;
				}
			}
		}

		public bool IsStrict
		{
			get
			{
				return HasFlag(1);
			}
			set
			{
				SetFlag(1, value);
			}
		}

		public bool IsPacked
		{
			get
			{
				return HasFlag(2);
			}
			set
			{
				SetFlag(2, value);
			}
		}

		public bool OverwriteList
		{
			get
			{
				return HasFlag(8);
			}
			set
			{
				SetFlag(8, value);
			}
		}

		public bool IsRequired
		{
			get
			{
				return HasFlag(4);
			}
			set
			{
				SetFlag(4, value);
			}
		}

		public bool AsReference
		{
			get
			{
				return false;
			}
			[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", true)]
			set
			{
				if (value != AsReference)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
				}
			}
		}

		public bool DynamicType
		{
			get
			{
				return false;
			}
			[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", true)]
			set
			{
				if (value != DynamicType)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
				}
			}
		}

		public bool IsMap
		{
			get
			{
				return HasFlag(64);
			}
			set
			{
				SetFlag(64, value);
			}
		}

		public DataFormat MapKeyFormat
		{
			get
			{
				return mapKeyFormat;
			}
			set
			{
				if (mapKeyFormat != value)
				{
					ThrowIfFrozen();
					mapKeyFormat = value;
				}
			}
		}

		public DataFormat MapValueFormat
		{
			get
			{
				return mapValueFormat;
			}
			set
			{
				if (mapValueFormat != value)
				{
					ThrowIfFrozen();
					mapValueFormat = value;
				}
			}
		}

		public string Name
		{
			get
			{
				if (!string.IsNullOrEmpty(name))
				{
					return name;
				}
				return Member.Name;
			}
			set
			{
				SetName(value);
			}
		}

		public bool SupportNull
		{
			get
			{
				return HasFlag(512);
			}
			set
			{
				SetFlag(512, value);
			}
		}

		internal bool NullWrappedValue
		{
			get
			{
				return HasFlag(16);
			}
			set
			{
				SetFlag(16, value);
			}
		}

		internal bool NullWrappedValueGroup
		{
			get
			{
				return HasFlag(32);
			}
			set
			{
				SetFlag(32, value);
			}
		}

		internal bool NullWrappedCollection
		{
			get
			{
				return HasFlag(128);
			}
			set
			{
				SetFlag(128, value);
			}
		}

		internal bool NullWrappedCollectionGroup
		{
			get
			{
				return HasFlag(256);
			}
			set
			{
				SetFlag(256, value);
			}
		}

		internal bool RequiresGroupModifier
		{
			get
			{
				if (!SupportNull)
				{
					return NullWrappedValueGroup;
				}
				return true;
			}
		}

		internal static CompatibilityLevel GetEffectiveCompatibilityLevel(CompatibilityLevel compatibilityLevel, DataFormat dataFormat)
		{
			if (compatibilityLevel <= CompatibilityLevel.Level200)
			{
				if (dataFormat == DataFormat.WellKnown)
				{
					return CompatibilityLevel.Level240;
				}
				return CompatibilityLevel.Level200;
			}
			return compatibilityLevel;
		}

		public ValueMember(RuntimeTypeModel model, Type parentType, int fieldNumber, MemberInfo member, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat, object defaultValue)
			: this(model, fieldNumber, memberType, itemType, defaultType, dataFormat)
		{
			if ((object)parentType == null)
			{
				throw new ArgumentNullException("parentType");
			}
			if (fieldNumber < 1 && !parentType.IsEnum)
			{
				throw new ArgumentOutOfRangeException("fieldNumber");
			}
			Member = member ?? throw new ArgumentNullException("member");
			ParentType = parentType;
			if (fieldNumber < 1 && !parentType.IsEnum)
			{
				throw new ArgumentOutOfRangeException("fieldNumber");
			}
			if (defaultValue != null && defaultValue.GetType() != memberType)
			{
				defaultValue = ParseDefaultValue(memberType, defaultValue);
			}
			_defaultValue = defaultValue;
		}

		internal ValueMember(RuntimeTypeModel model, int fieldNumber, Type memberType, Type itemType, Type defaultType, DataFormat dataFormat)
		{
			FieldNumber = fieldNumber;
			MemberType = memberType ?? throw new ArgumentNullException("memberType");
			ItemType = itemType;
			if ((object)defaultType == null && (object)itemType != null)
			{
				defaultType = memberType;
			}
			DefaultType = defaultType;
			this.model = model ?? throw new ArgumentNullException("model");
			this.dataFormat = dataFormat;
		}

		internal object GetRawEnumValue()
		{
			return ((FieldInfo)Member).GetRawConstantValue();
		}

		private static object ParseDefaultValue(Type type, object value)
		{
			Type underlyingType = Nullable.GetUnderlyingType(type);
			if ((object)underlyingType != null)
			{
				type = underlyingType;
			}
			if (value is string text)
			{
				if (type.IsEnum)
				{
					return Enum.Parse(type, text, ignoreCase: true);
				}
				switch (Helpers.GetTypeCode(type))
				{
				case ProtoTypeCode.Boolean:
					return bool.Parse(text);
				case ProtoTypeCode.Byte:
					return byte.Parse(text, NumberStyles.Integer, CultureInfo.InvariantCulture);
				case ProtoTypeCode.Char:
					if (text.Length == 1)
					{
						return text[0];
					}
					throw new FormatException("Single character expected: \"" + text + "\"");
				case ProtoTypeCode.DateTime:
					return DateTime.Parse(text, CultureInfo.InvariantCulture);
				case ProtoTypeCode.Decimal:
					return decimal.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.Double:
					return double.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.Int16:
					return short.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.Int32:
					return int.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.Int64:
					return long.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.SByte:
					return sbyte.Parse(text, NumberStyles.Integer, CultureInfo.InvariantCulture);
				case ProtoTypeCode.Single:
					return float.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.String:
					return text;
				case ProtoTypeCode.UInt16:
					return ushort.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.UInt32:
					return uint.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.UInt64:
					return ulong.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture);
				case ProtoTypeCode.TimeSpan:
					return TimeSpan.Parse(text);
				case ProtoTypeCode.Uri:
					return text;
				case ProtoTypeCode.Guid:
					return new Guid(text);
				case ProtoTypeCode.IntPtr:
					return new IntPtr(long.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture));
				case ProtoTypeCode.UIntPtr:
					return new UIntPtr(ulong.Parse(text, NumberStyles.Any, CultureInfo.InvariantCulture));
				}
			}
			if (type.IsEnum)
			{
				return Enum.ToObject(type, value);
			}
			try
			{
				return Convert.ChangeType(value, type, CultureInfo.InvariantCulture);
			}
			catch (InvalidCastException) when (type == typeof(IntPtr))
			{
				return new IntPtr((long)Convert.ChangeType(value, typeof(long), CultureInfo.InvariantCulture));
			}
			catch (InvalidCastException) when (type == typeof(UIntPtr))
			{
				return new UIntPtr((ulong)Convert.ChangeType(value, typeof(ulong), CultureInfo.InvariantCulture));
			}
		}

		public void SetSpecified(MethodInfo getSpecified, MethodInfo setSpecified)
		{
			if (this.getSpecified != getSpecified || this.setSpecified != setSpecified)
			{
				if ((object)getSpecified != null && (getSpecified.ReturnType != typeof(bool) || getSpecified.IsStatic || getSpecified.GetParameters().Length != 0))
				{
					throw new ArgumentException("Invalid pattern for checking member-specified", "getSpecified");
				}
				ParameterInfo[] parameters;
				if ((object)setSpecified != null && (setSpecified.ReturnType != typeof(void) || setSpecified.IsStatic || (parameters = setSpecified.GetParameters()).Length != 1 || parameters[0].ParameterType != typeof(bool)))
				{
					throw new ArgumentException("Invalid pattern for setting member-specified", "setSpecified");
				}
				ThrowIfFrozen();
				this.getSpecified = getSpecified;
				this.setSpecified = setSpecified;
			}
		}

		private void ThrowIfFrozen()
		{
			if (serializer != null)
			{
				throw new InvalidOperationException("The type cannot be changed once a serializer has been generated");
			}
		}

		internal static IRuntimeProtoSerializerNode CreateMap(RepeatedSerializerStub repeated, RuntimeTypeModel model, DataFormat dataFormat, CompatibilityLevel compatibilityLevel, DataFormat keyFormat, DataFormat valueFormat, bool asReference, bool dynamicType, bool isMap, bool overwriteList, int fieldNumber, ValueMember member)
		{
			CompatibilityLevel effectiveCompatibilityLevel = GetEffectiveCompatibilityLevel(compatibilityLevel, keyFormat);
			CompatibilityLevel effectiveCompatibilityLevel2 = GetEffectiveCompatibilityLevel(compatibilityLevel, valueFormat);
			repeated.ResolveMapTypes(out var keyType, out var valueType);
			TryGetCoreSerializer(model, keyFormat, effectiveCompatibilityLevel, FlattenRepeated(model, keyType), out var defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: true);
			TryGetCoreSerializer(model, valueFormat, effectiveCompatibilityLevel2, FlattenRepeated(model, valueType), out var defaultWireType2, asReference, dynamicType, overwriteList: false, allowComplexTypes: true);
			WireType wireType = ((dataFormat == DataFormat.Group) ? WireType.StartGroup : WireType.String);
			SerializerFeatures listFeatures = wireType.AsFeatures();
			if (!isMap)
			{
				listFeatures |= SerializerFeatures.OptionFailOnDuplicateKey;
			}
			if (overwriteList)
			{
				listFeatures |= SerializerFeatures.OptionClearCollection;
			}
			member?.ComposeListFeatures(ref listFeatures);
			SerializerFeatures serializerFeatures = defaultWireType2.AsFeatures();
			serializerFeatures |= listFeatures & (SerializerFeatures.OptionWrappedValue | SerializerFeatures.OptionWrappedValueGroup);
			listFeatures &= ~(SerializerFeatures.OptionWrappedValue | SerializerFeatures.OptionWrappedValueGroup);
			return MapDecorator.Create(repeated, keyType, valueType, fieldNumber, listFeatures, defaultWireType.AsFeatures(), effectiveCompatibilityLevel, keyFormat, serializerFeatures, effectiveCompatibilityLevel2, valueFormat);
			static Type FlattenRepeated(RuntimeTypeModel model, Type type)
			{
				if ((object)type == null)
				{
					return type;
				}
				RepeatedSerializerStub repeatedSerializerStub = ((model == null) ? RepeatedSerializers.TryGetRepeatedProvider(type) : model.TryGetRepeatedProvider(type));
				if (repeatedSerializerStub != null)
				{
					return repeatedSerializerStub.ItemType;
				}
				return type;
			}
		}

		private void ComposeListFeatures(ref SerializerFeatures listFeatures)
		{
			if (!IsPacked)
			{
				listFeatures |= SerializerFeatures.OptionPackedDisabled;
			}
			if (OverwriteList)
			{
				listFeatures |= SerializerFeatures.OptionClearCollection;
			}
			if (SupportNull)
			{
				if (NullWrappedValue || NullWrappedCollection || IsPacked)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("SupportNull cannot be combined with IsPacked, NullWrappedValue or NullWrappedCollection");
				}
				listFeatures |= SerializerFeatures.OptionWrappedValue | SerializerFeatures.OptionWrappedValueGroup;
				return;
			}
			if (NullWrappedCollection)
			{
				listFeatures |= SerializerFeatures.OptionWrappedCollection;
				if (NullWrappedCollectionGroup)
				{
					listFeatures |= SerializerFeatures.OptionWrappedCollectionGroup;
				}
			}
			if (NullWrappedValue)
			{
				listFeatures |= SerializerFeatures.OptionWrappedValue | SerializerFeatures.OptionWrappedValueFieldPresence;
				if (NullWrappedValueGroup)
				{
					listFeatures |= SerializerFeatures.OptionWrappedValueGroup;
				}
			}
		}

		private IRuntimeProtoSerializerNode BuildSerializer()
		{
			int opaqueToken = 0;
			try
			{
				model.TakeLock(ref opaqueToken);
				MemberInfo memberInfo = backingMember ?? Member;
				RepeatedSerializerStub repeatedSerializerStub = model.TryGetRepeatedProvider(MemberType);
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode;
				if (repeatedSerializerStub != null)
				{
					if (repeatedSerializerStub.IsMap)
					{
						runtimeProtoSerializerNode = CreateMap(repeatedSerializerStub, model, DataFormat, CompatibilityLevel, MapKeyFormat, MapValueFormat, AsReference, DynamicType, IsMap, OverwriteList, FieldNumber, this);
					}
					else
					{
						TryGetCoreSerializer(model, DataFormat, CompatibilityLevel, repeatedSerializerStub.ItemType, out var defaultWireType, AsReference, DynamicType, OverwriteList, allowComplexTypes: true);
						SerializerFeatures listFeatures = defaultWireType.AsFeatures();
						ComposeListFeatures(ref listFeatures);
						runtimeProtoSerializerNode = RepeatedDecorator.Create(repeatedSerializerStub, FieldNumber, listFeatures, CompatibilityLevel, DataFormat);
					}
				}
				else
				{
					if (NullWrappedCollection)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("NullWrappedCollection can only be used with collection types");
					}
					runtimeProtoSerializerNode = TryGetCoreSerializer(model, DataFormat, CompatibilityLevel, MemberType, out var defaultWireType2, AsReference, DynamicType, OverwriteList, allowComplexTypes: true);
					if (runtimeProtoSerializerNode == null)
					{
						ProtoBuf.Internal.ThrowHelper.NoSerializerDefined(MemberType);
					}
					if (NullWrappedValue)
					{
						SerializerFeatures serializerFeatures = SerializerFeatures.OptionWrappedValue;
						if (NullWrappedValueGroup)
						{
							serializerFeatures |= SerializerFeatures.OptionWrappedValueGroup;
						}
						if (MemberType.IsValueType && (object)Nullable.GetUnderlyingType(MemberType) == null)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("NullWrappedValue cannot be used with non-nullable values");
						}
						if (_defaultValue != null)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("NullWrappedValue cannot be used with default values");
						}
						if (IsRequired)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("NullWrappedValue cannot be used with required values");
						}
						if (IsPacked)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("NullWrappedValue cannot be used with packed values");
						}
						if (DataFormat != 0)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("NullWrappedValue can only be used with DataFormat.Default");
						}
						if (!runtimeProtoSerializerNode.IsScalar)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("NullWrappedValue can only be used with scalar types, or in a collection");
						}
						runtimeProtoSerializerNode = AnyTypeSerializer.Create(MemberType, serializerFeatures, CompatibilityLevel, DataFormat);
					}
					runtimeProtoSerializerNode = new TagDecorator(FieldNumber, defaultWireType2, IsStrict, runtimeProtoSerializerNode);
					if (_defaultValue != null && !IsRequired && (object)getSpecified == null)
					{
						runtimeProtoSerializerNode = new DefaultValueDecorator(_defaultValue, runtimeProtoSerializerNode);
					}
					if (MemberType == typeof(Uri))
					{
						runtimeProtoSerializerNode = new UriDecorator(runtimeProtoSerializerNode);
					}
				}
				if ((object)memberInfo != null)
				{
					if (memberInfo is PropertyInfo property)
					{
						runtimeProtoSerializerNode = new PropertyDecorator(ParentType, property, runtimeProtoSerializerNode);
					}
					else
					{
						if (!(memberInfo is FieldInfo field))
						{
							throw new InvalidOperationException();
						}
						runtimeProtoSerializerNode = new FieldDecorator(ParentType, field, runtimeProtoSerializerNode);
					}
					if ((object)getSpecified != null || (object)setSpecified != null)
					{
						runtimeProtoSerializerNode = new MemberSpecifiedDecorator(getSpecified, setSpecified, runtimeProtoSerializerNode);
					}
				}
				return runtimeProtoSerializerNode;
			}
			finally
			{
				model.ReleaseLock(opaqueToken);
			}
		}

		private static WireType GetIntWireType(DataFormat format, int width)
		{
			switch (format)
			{
			case DataFormat.ZigZag:
				return WireType.SignedVariant;
			case DataFormat.FixedSize:
				if (width != 32)
				{
					return WireType.Fixed64;
				}
				return WireType.Fixed32;
			case DataFormat.TwosComplement:
			case DataFormat.WellKnown:
				return WireType.Variant;
			case DataFormat.Default:
				return WireType.Variant;
			default:
				throw new InvalidOperationException();
			}
		}

		private static WireType GetDateTimeWireType(DataFormat format)
		{
			switch (format)
			{
			case DataFormat.Group:
				return WireType.StartGroup;
			case DataFormat.FixedSize:
				return WireType.Fixed64;
			case DataFormat.Default:
			case DataFormat.WellKnown:
				return WireType.String;
			default:
				throw new InvalidOperationException();
			}
		}

		internal static IRuntimeProtoSerializerNode TryGetCoreSerializer(RuntimeTypeModel model, DataFormat dataFormat, CompatibilityLevel compatibilityLevel, Type type, out WireType defaultWireType, bool asReference, bool dynamicType, bool overwriteList, bool allowComplexTypes)
		{
			compatibilityLevel = GetEffectiveCompatibilityLevel(compatibilityLevel, dataFormat);
			type = DynamicStub.GetEffectiveType(type);
			if (type.IsEnum)
			{
				if (allowComplexTypes && model != null)
				{
					defaultWireType = WireType.Variant;
					return new EnumMemberSerializer(type);
				}
				defaultWireType = WireType.None;
				return null;
			}
			switch (Helpers.GetTypeCode(type))
			{
			case ProtoTypeCode.Int32:
				defaultWireType = GetIntWireType(dataFormat, 32);
				return Int32Serializer.Instance;
			case ProtoTypeCode.UInt32:
				defaultWireType = GetIntWireType(dataFormat, 32);
				return UInt32Serializer.Instance;
			case ProtoTypeCode.Int64:
				defaultWireType = GetIntWireType(dataFormat, 64);
				return Int64Serializer.Instance;
			case ProtoTypeCode.UInt64:
				defaultWireType = GetIntWireType(dataFormat, 64);
				return UInt64Serializer.Instance;
			case ProtoTypeCode.String:
				defaultWireType = WireType.String;
				if (asReference)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited");
					return null;
				}
				return StringSerializer.Instance;
			case ProtoTypeCode.Single:
				defaultWireType = WireType.Fixed32;
				return SingleSerializer.Instance;
			case ProtoTypeCode.Double:
				defaultWireType = WireType.Fixed64;
				return DoubleSerializer.Instance;
			case ProtoTypeCode.Boolean:
				defaultWireType = WireType.Variant;
				return BooleanSerializer.Instance;
			case ProtoTypeCode.DateTime:
				defaultWireType = GetDateTimeWireType(dataFormat);
				return DateTimeSerializer.Create(compatibilityLevel, model);
			case ProtoTypeCode.Decimal:
				defaultWireType = WireType.String;
				return DecimalSerializer.Create(compatibilityLevel);
			case ProtoTypeCode.Byte:
				defaultWireType = GetIntWireType(dataFormat, 32);
				return ByteSerializer.Instance;
			case ProtoTypeCode.SByte:
				defaultWireType = GetIntWireType(dataFormat, 32);
				return SByteSerializer.Instance;
			case ProtoTypeCode.Char:
				defaultWireType = WireType.Variant;
				return CharSerializer.Instance;
			case ProtoTypeCode.Int16:
				defaultWireType = GetIntWireType(dataFormat, 32);
				return Int16Serializer.Instance;
			case ProtoTypeCode.UInt16:
				defaultWireType = GetIntWireType(dataFormat, 32);
				return UInt16Serializer.Instance;
			case ProtoTypeCode.TimeSpan:
				defaultWireType = GetDateTimeWireType(dataFormat);
				return TimeSpanSerializer.Create(compatibilityLevel);
			case ProtoTypeCode.Guid:
				defaultWireType = ((dataFormat == DataFormat.Group && compatibilityLevel < CompatibilityLevel.Level300) ? WireType.StartGroup : WireType.String);
				return GuidSerializer.Create(compatibilityLevel, dataFormat);
			case ProtoTypeCode.Uri:
				defaultWireType = WireType.String;
				return StringSerializer.Instance;
			case ProtoTypeCode.ByteArray:
				defaultWireType = WireType.String;
				return new BlobSerializer<byte[]>(overwriteList);
			case ProtoTypeCode.ByteArraySegment:
				defaultWireType = WireType.String;
				return new BlobSerializer<ArraySegment<byte>>(overwriteList);
			case ProtoTypeCode.ByteMemory:
				defaultWireType = WireType.String;
				return new BlobSerializer<Memory<byte>>(overwriteList);
			case ProtoTypeCode.ByteReadOnlyMemory:
				defaultWireType = WireType.String;
				return new BlobSerializer<ReadOnlyMemory<byte>>(overwriteList);
			case ProtoTypeCode.Type:
				defaultWireType = WireType.String;
				return SystemTypeSerializer.Instance;
			case ProtoTypeCode.IntPtr:
				defaultWireType = GetIntWireType(dataFormat, 64);
				return IntPtrSerializer.Instance;
			case ProtoTypeCode.UIntPtr:
				defaultWireType = GetIntWireType(dataFormat, 64);
				return UIntPtrSerializer.Instance;
			default:
			{
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode = (model.AllowParseableTypes ? ParseableSerializer.TryCreate(type) : null);
				if (runtimeProtoSerializerNode != null)
				{
					defaultWireType = WireType.String;
					return runtimeProtoSerializerNode;
				}
				if (allowComplexTypes && model != null)
				{
					MetaType metaType = null;
					if (model.IsDefined(type, compatibilityLevel))
					{
						metaType = model.FindWithAmbientCompatibility(type, compatibilityLevel);
						if (dataFormat == DataFormat.Default && metaType.IsGroup)
						{
							dataFormat = DataFormat.Group;
						}
					}
					if (asReference || dynamicType)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited");
						defaultWireType = WireType.Variant;
						return null;
					}
					if (metaType != null)
					{
						IProtoTypeSerializer protoTypeSerializer;
						if (metaType.HasSurrogate && (protoTypeSerializer = metaType.Serializer).Features.GetCategory() == SerializerFeatures.CategoryScalar)
						{
							dataFormat = metaType.surrogateDataFormat;
							if (TryGetCoreSerializer(model, dataFormat, metaType.CompatibilityLevel, metaType.surrogateType, out defaultWireType, asReference: false, dynamicType: false, overwriteList: false, allowComplexTypes: false) == null)
							{
								defaultWireType = protoTypeSerializer.Features.GetWireType();
							}
							return protoTypeSerializer;
						}
						return SubItemSerializer.Create(type, metaType, ref dataFormat, out defaultWireType);
					}
				}
				defaultWireType = WireType.None;
				return null;
			}
			}
		}

		internal void SetName(string name)
		{
			if (name != this.name)
			{
				ThrowIfFrozen();
				this.name = name;
			}
		}

		private bool HasFlag(ushort flag)
		{
			return (flags & flag) == flag;
		}

		private void SetFlag(ushort flag, bool value, bool throwIfFrozen = true)
		{
			if (throwIfFrozen && HasFlag(flag) != value)
			{
				ThrowIfFrozen();
			}
			if (value)
			{
				flags |= flag;
			}
			else
			{
				flags = (ushort)(flags & ~flag);
			}
		}

		internal bool HasExtendedNullSupport()
		{
			if (!SupportNull && !NullWrappedValueGroup)
			{
				return NullWrappedValue;
			}
			return true;
		}

		internal bool RequiresExtraLayerInSchema()
		{
			if ((object)ItemType != null)
			{
				return HasExtendedNullSupport();
			}
			return false;
		}

		internal string GetSchemaTypeName(HashSet<Type> callstack, bool applyNetObjectProxy, HashSet<string> imports, out string altName, bool considerWrappersProtoTypes = false)
		{
			Type effectiveType = ItemType ?? MemberType;
			return model.GetSchemaTypeName(callstack, effectiveType, DataFormat, CompatibilityLevel, applyNetObjectProxy && AsReference, applyNetObjectProxy && DynamicType, imports, out altName, considerWrappersProtoTypes);
		}
	}
}
namespace ProtoBuf.Internal
{
	internal sealed class BasicList : IEnumerable
	{
		[StructLayout(LayoutKind.Auto)]
		public struct NodeEnumerator : IEnumerator
		{
			private int position;

			private readonly Node node;

			public object Current => node[position];

			internal NodeEnumerator(Node node)
			{
				position = -1;
				this.node = node;
			}

			void IEnumerator.Reset()
			{
				position = -1;
			}

			public bool MoveNext()
			{
				int length = node.Length;
				if (position <= length)
				{
					return ++position < length;
				}
				return false;
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[<da4ae7fc-788b-41bf-a5c9-fb56955443e9>IsReadOnly]
		internal struct Node
		{
			private readonly object[] data;

			public object this[int index]
			{
				get
				{
					if (index >= 0 && index < Length)
					{
						return data[index];
					}
					throw new ArgumentOutOfRangeException("index");
				}
				set
				{
					if (index >= 0 && index < Length)
					{
						data[index] = value;
						return;
					}
					throw new ArgumentOutOfRangeException("index");
				}
			}

			public int Length { get; }

			internal Node(object[] data, int length)
			{
				this.data = data;
				Length = length;
			}

			public Node Append(object value)
			{
				int length = Length + 1;
				object[] array;
				if (data == null)
				{
					array = new object[10];
				}
				else if (Length == data.Length)
				{
					array = new object[data.Length * 2];
					Array.Copy(data, array, Length);
				}
				else
				{
					array = data;
				}
				array[Length] = value;
				return new Node(array, length);
			}

			internal int IndexOfReference(object instance)
			{
				for (int i = 0; i < Length; i++)
				{
					if (instance == data[i])
					{
						return i;
					}
				}
				return -1;
			}

			internal int IndexOf(MatchPredicate predicate, object ctx)
			{
				for (int i = 0; i < Length; i++)
				{
					if (predicate(data[i], ctx))
					{
						return i;
					}
				}
				return -1;
			}
		}

		internal delegate bool MatchPredicate(object value, object ctx);

		[StructLayout(LayoutKind.Auto)]
		[<da4ae7fc-788b-41bf-a5c9-fb56955443e9>IsReadOnly]
		internal struct Group<T>
		{
			public readonly int First;

			public readonly List<T> Items;

			public bool IsEmpty => Items == null;

			public Group(int first)
			{
				First = first;
				Items = new List<T>();
			}
		}

		private static readonly Node nil = new Node(null, 0);

		private Node head = nil;

		public object this[int index] => head[index];

		public int Count => head.Length;

		public int Add(object value)
		{
			Node node = (head = head.Append(value));
			return node.Length - 1;
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new NodeEnumerator(head);
		}

		public NodeEnumerator GetEnumerator()
		{
			return new NodeEnumerator(head);
		}

		internal int IndexOf(MatchPredicate predicate, object ctx)
		{
			return head.IndexOf(predicate, ctx);
		}

		internal bool Contains(object value)
		{
			NodeEnumerator enumerator = GetEnumerator();
			while (enumerator.MoveNext())
			{
				object current = enumerator.Current;
				if (object.Equals(current, value))
				{
					return true;
				}
			}
			return false;
		}

		internal static List<Group<T>> GetContiguousGroups<T>(int[] keys, T[] values)
		{
			if (keys == null)
			{
				throw new ArgumentNullException("keys");
			}
			if (values == null)
			{
				throw new ArgumentNullException("values");
			}
			if (values.Length < keys.Length)
			{
				throw new ArgumentException("Not all keys are covered by values", "values");
			}
			List<Group<T>> list = new List<Group<T>>();
			Group<T> item = default(Group<T>);
			for (int i = 0; i < keys.Length; i++)
			{
				if (i == 0 || keys[i] != keys[i - 1])
				{
					item = default(Group<T>);
				}
				if (item.IsEmpty)
				{
					item = new Group<T>(keys[i]);
					list.Add(item);
				}
				item.Items.Add(values[i]);
			}
			return list;
		}

		internal bool Any()
		{
			return Count != 0;
		}
	}
	internal static class TypeCompatibilityHelper
	{
		private static readonly Dictionary<Module, CompatibilityLevel> s_ByModule = new Dictionary<Module, CompatibilityLevel>();

		internal static CompatibilityLevel GetModuleCompatibilityLevel(Module module)
		{
			if ((object)module == null)
			{
				return CompatibilityLevel.NotSpecified;
			}
			lock (s_ByModule)
			{
				if (s_ByModule.TryGetValue(module, out var value))
				{
					return value;
				}
			}
			CompatibilityLevel compatibilityLevel = Calculate(module);
			lock (s_ByModule)
			{
				s_ByModule[module] = compatibilityLevel;
				return compatibilityLevel;
			}
			static CompatibilityLevel Calculate(Module module)
			{
				if (Attribute.GetCustomAttribute(module, typeof(CompatibilityLevelAttribute), inherit: true) is CompatibilityLevelAttribute compatibilityLevelAttribute && compatibilityLevelAttribute.Level > CompatibilityLevel.NotSpecified)
				{
					return compatibilityLevelAttribute.Level;
				}
				Assembly assembly = module.Assembly;
				if ((object)assembly != null && Attribute.GetCustomAttribute(assembly, typeof(CompatibilityLevelAttribute), inherit: true) is CompatibilityLevelAttribute compatibilityLevelAttribute2 && compatibilityLevelAttribute2.Level > CompatibilityLevel.NotSpecified)
				{
					return compatibilityLevelAttribute2.Level;
				}
				return CompatibilityLevel.NotSpecified;
			}
		}

		internal static CompatibilityLevel GetTypeCompatibilityLevel(Type type, CompatibilityLevel defaultLevel)
		{
			if (Attribute.GetCustomAttribute(type, typeof(CompatibilityLevelAttribute), inherit: true) is CompatibilityLevelAttribute compatibilityLevelAttribute && compatibilityLevelAttribute.Level > CompatibilityLevel.NotSpecified)
			{
				return compatibilityLevelAttribute.Level;
			}
			CompatibilityLevel moduleCompatibilityLevel = GetModuleCompatibilityLevel(type.Module);
			if (moduleCompatibilityLevel > CompatibilityLevel.NotSpecified)
			{
				return moduleCompatibilityLevel;
			}
			if (defaultLevel >= CompatibilityLevel.Level200)
			{
				return defaultLevel;
			}
			return CompatibilityLevel.Level200;
		}

		internal static CompatibilityLevel GetMemberCompatibilityLevel(MemberInfo member, CompatibilityLevel typeLevel)
		{
			if (!(Attribute.GetCustomAttribute(member, typeof(CompatibilityLevelAttribute), inherit: true) is CompatibilityLevelAttribute compatibilityLevelAttribute) || compatibilityLevelAttribute.Level <= CompatibilityLevel.NotSpecified)
			{
				return typeLevel;
			}
			return compatibilityLevelAttribute.Level;
		}
	}
}
namespace ProtoBuf.Internal.Serializers
{
	internal sealed class AnyTypeSerializer<T> : IRuntimeProtoSerializerNode, IDirectWriteNode, IDirectRuntimeWriteNode
	{
		private readonly SerializerFeatures _features;

		private readonly CompatibilityLevel _compatibilityLevel;

		private readonly DataFormat _dataFormat;

		private static readonly MethodInfo ReadAnyT = AnyTypeSerializer.ReadAnyT.MakeGenericMethod(typeof(T));

		private static readonly MethodInfo WriteAnyT = AnyTypeSerializer.WriteAnyT.MakeGenericMethod(typeof(T));

		bool IRuntimeProtoSerializerNode.IsScalar => _features.IsScalar();

		public Type ExpectedType => typeof(T);

		bool IRuntimeProtoSerializerNode.RequiresOldValue => true;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public AnyTypeSerializer(SerializerFeatures features, CompatibilityLevel compatibilityLevel, DataFormat dataFormat)
		{
			_features = features;
			_compatibilityLevel = compatibilityLevel;
			_dataFormat = dataFormat;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadAny(_features, (T)value);
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			throw new NotSupportedException("Only DirectWrite should be used");
		}

		void IDirectRuntimeWriteNode.DirectWrite(int fieldNumber, WireType wireType, ref ProtoWriter.State state, object value)
		{
			state.WriteAny(fieldNumber, _features | wireType.AsFeatures(), (T)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			throw new NotSupportedException("Only EmitDirectWrite should be used");
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			using Local local = ctx.GetLocalWithValue(typeof(T), entity);
			ctx.LoadState();
			ctx.LoadValue((int)_features);
			ctx.LoadValue(local);
			ctx.LoadSelfAsService<ISerializer<T>, T>(_compatibilityLevel, _dataFormat);
			ctx.EmitCall(ReadAnyT);
		}

		bool IDirectWriteNode.CanEmitDirectWrite(WireType wireType)
		{
			return true;
		}

		bool IDirectRuntimeWriteNode.CanDirectWrite(WireType wireType)
		{
			return true;
		}

		void IDirectWriteNode.EmitDirectWrite(int fieldNumber, WireType wireType, CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(T), valueFrom);
			ctx.LoadState();
			ctx.LoadValue(fieldNumber);
			ctx.LoadValue((int)(_features | wireType.AsFeatures()));
			ctx.LoadValue(local);
			ctx.LoadSelfAsService<ISerializer<T>, T>(_compatibilityLevel, _dataFormat);
			ctx.EmitCall(WriteAnyT);
		}
	}
	internal static class AnyTypeSerializer
	{
		internal static readonly MethodInfo ReadAnyT = FindSerializerFeaturesMethod(typeof(ProtoReader.State), "ReadAny");

		internal static readonly MethodInfo WriteAnyT = FindSerializerFeaturesMethod(typeof(ProtoWriter.State), "WriteAny");

		private static bool FindSerializerFeaturesMethodFilter(MemberInfo member, object state)
		{
			if (member is MethodInfo methodInfo && state is string text && member.Name == text)
			{
				ParameterInfo[] parameters = methodInfo.GetParameters();
				foreach (ParameterInfo parameterInfo in parameters)
				{
					if (parameterInfo.ParameterType == typeof(SerializerFeatures))
					{
						return true;
					}
				}
			}
			return false;
		}

		private static MethodInfo FindSerializerFeaturesMethod(Type type, string name)
		{
			return (MethodInfo)type.FindMembers(MemberTypes.Method, BindingFlags.Instance | BindingFlags.Public, FindSerializerFeaturesMethodFilter, name).Single();
		}

		internal static IRuntimeProtoSerializerNode Create(Type memberType, SerializerFeatures features, CompatibilityLevel compatibilityLevel, DataFormat dataFormat)
		{
			return (IRuntimeProtoSerializerNode)Activator.CreateInstance(typeof(AnyTypeSerializer<>).MakeGenericType(memberType), features, compatibilityLevel, dataFormat);
		}
	}
	internal sealed class BlobSerializer<T> : IRuntimeProtoSerializerNode
	{
		private static readonly Type expectedType = typeof(T);

		private readonly bool overwriteList;

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => !overwriteList;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public BlobSerializer(bool overwriteList)
		{
			this.overwriteList = overwriteList;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.AppendBytes(overwriteList ? default(T) : ((T)value));
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteBytes((T)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteBytes", valueFrom, null, typeof(T));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			using Local local = (overwriteList ? null : ctx.GetLocalWithValue(typeof(T), entity));
			ctx.LoadState();
			if (overwriteList)
			{
				ctx.LoadNullRef();
			}
			else
			{
				ctx.LoadValue(local);
			}
			ctx.EmitCall(typeof(ProtoReader.State).GetMethod("AppendBytes", new Type[1] { typeof(T) }));
		}
	}
	internal sealed class BooleanSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly BooleanSerializer Instance = new BooleanSerializer();

		private static readonly Type expectedType = typeof(bool);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private BooleanSerializer()
		{
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteBoolean((bool)value);
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadBoolean();
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteBoolean", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadBoolean", ExpectedType);
		}
	}
	internal sealed class ByteSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly ByteSerializer Instance = new ByteSerializer();

		private static readonly Type expectedType = typeof(byte);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private ByteSerializer()
		{
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteByte((byte)value);
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadByte();
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteByte", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadByte", ExpectedType);
		}
	}
	internal sealed class CharSerializer : UInt16Serializer
	{
		internal new static readonly CharSerializer Instance = new CharSerializer();

		private static readonly Type expectedType = typeof(char);

		public override Type ExpectedType => expectedType;

		private CharSerializer()
		{
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteUInt16((char)value);
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			return (char)state.ReadUInt16();
		}
	}
	internal sealed class InheritanceCompiledSerializer<TBase, T> : CompiledSerializer, ISerializer<T>, ISubTypeSerializer<T>, IFactory<T> where TBase : class where T : class, TBase
	{
		private readonly ProtoSerializer<T> subTypeSerializer;

		private readonly ProtoSubTypeDeserializer<T> subTypeDeserializer;

		private readonly Func<ISerializationContext, T> factory;

		T ISerializer<T>.Read(ref ProtoReader.State state, T value)
		{
			return state.ReadBaseType<TBase, T>(value);
		}

		T IFactory<T>.Create(ISerializationContext context)
		{
			Func<ISerializationContext, T> func = factory;
			if (func == null)
			{
				return null;
			}
			return func(context);
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadBaseType<TBase, T>(TypeHelper<T>.FromObject(value));
		}

		void ISerializer<T>.Write(ref ProtoWriter.State state, T value)
		{
			state.WriteBaseType((TBase)value);
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteBaseType((TBase)TypeHelper<T>.FromObject(value));
		}

		void ISubTypeSerializer<T>.WriteSubType(ref ProtoWriter.State state, T value)
		{
			subTypeSerializer(ref state, value);
		}

		T ISubTypeSerializer<T>.ReadSubType(ref ProtoReader.State state, SubTypeState<T> value)
		{
			return subTypeDeserializer(ref state, value);
		}

		public InheritanceCompiledSerializer(IProtoTypeSerializer head, RuntimeTypeModel model)
			: base(head)
		{
			try
			{
				subTypeSerializer = CompilerContext.BuildSerializer<T>(model.Scope, head, model);
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException("Unable to bind serializer: " + ex.Message, ex);
			}
			try
			{
				subTypeDeserializer = CompilerContext.BuildSubTypeDeserializer<T>(model.Scope, head, model);
			}
			catch (Exception ex2)
			{
				throw new InvalidOperationException("Unable to bind deserializer: " + ex2.Message, ex2);
			}
			factory = CompilerContext.BuildFactory<T>(model.Scope, head, model);
		}
	}
	internal class SimpleCompiledSerializer<T> : CompiledSerializer, ISerializer<T>, IFactory<T>
	{
		protected readonly ProtoSerializer<T> serializer;

		protected readonly ProtoDeserializer<T> deserializer;

		private readonly Func<ISerializationContext, T> factory;

		public SimpleCompiledSerializer(IProtoTypeSerializer head, RuntimeTypeModel model)
			: base(head)
		{
			try
			{
				serializer = CompilerContext.BuildSerializer<T>(model.Scope, head, model);
			}
			catch (Exception ex)
			{
				throw new InvalidOperationException("Unable to bind serializer: " + ex.Message, ex);
			}
			try
			{
				deserializer = CompilerContext.BuildDeserializer<T>(model.Scope, head, model);
			}
			catch (Exception ex2)
			{
				throw new InvalidOperationException("Unable to bind deserializer: " + ex2.Message, ex2);
			}
			factory = CompilerContext.BuildFactory<T>(model.Scope, head, model);
		}

		T ISerializer<T>.Read(ref ProtoReader.State state, T value)
		{
			return deserializer(ref state, value);
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			return deserializer(ref state, TypeHelper<T>.FromObject(value));
		}

		void ISerializer<T>.Write(ref ProtoWriter.State state, T value)
		{
			serializer(ref state, value);
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			serializer(ref state, TypeHelper<T>.FromObject(value));
		}

		T IFactory<T>.Create(ISerializationContext context)
		{
			if (factory != null)
			{
				return factory(context);
			}
			return default(T);
		}
	}
	internal interface ICompiledSerializer
	{
		Type ExpectedType { get; }
	}
	internal abstract class CompiledSerializer : IProtoTypeSerializer, IRuntimeProtoSerializerNode, ICompiledSerializer
	{
		protected readonly IProtoTypeSerializer head;

		bool IRuntimeProtoSerializerNode.IsScalar => head.IsScalar;

		public SerializerFeatures Features => head.Features;

		bool IProtoTypeSerializer.IsSubType => head.IsSubType;

		Type IProtoTypeSerializer.BaseType => head.BaseType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => head.RequiresOldValue;

		bool IRuntimeProtoSerializerNode.ReturnsValue => head.ReturnsValue;

		public Type ExpectedType => head.ExpectedType;

		bool IProtoTypeSerializer.HasInheritance => head.HasInheritance;

		bool IProtoTypeSerializer.ShouldEmitCreateInstance => head.ShouldEmitCreateInstance;

		bool IProtoTypeSerializer.HasCallbacks(TypeModel.CallbackType callbackType)
		{
			return head.HasCallbacks(callbackType);
		}

		bool IProtoTypeSerializer.CanCreateInstance()
		{
			return head.CanCreateInstance();
		}

		object IProtoTypeSerializer.CreateInstance(ISerializationContext context)
		{
			return head.CreateInstance(context);
		}

		public void Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
			head.Callback(value, callbackType, context);
		}

		public static ICompiledSerializer Wrap(IProtoTypeSerializer head, RuntimeTypeModel model)
		{
			ICompiledSerializer compiledSerializer = head as ICompiledSerializer;
			if (compiledSerializer == null)
			{
				ConstructorInfo constructorInfo;
				try
				{
					constructorInfo = ((!head.IsSubType) ? Helpers.GetConstructor(typeof(SimpleCompiledSerializer<>).MakeGenericType(head.BaseType), new Type[2]
					{
						typeof(IProtoTypeSerializer),
						typeof(RuntimeTypeModel)
					}, nonPublic: true) : Helpers.GetConstructor(typeof(InheritanceCompiledSerializer<, >).MakeGenericType(head.BaseType, head.ExpectedType), new Type[2]
					{
						typeof(IProtoTypeSerializer),
						typeof(RuntimeTypeModel)
					}, nonPublic: true));
				}
				catch (Exception innerException)
				{
					throw new InvalidOperationException("Unable to wrap " + head.BaseType.NormalizeName() + "/" + head.ExpectedType.NormalizeName(), innerException);
				}
				try
				{
					compiledSerializer = (CompiledSerializer)constructorInfo.Invoke(new object[2] { head, model });
				}
				catch (TargetInvocationException ex)
				{
					throw new InvalidOperationException("Unable to wrap " + head.BaseType.NormalizeName() + "/" + head.ExpectedType.NormalizeName() + ": " + ex.InnerException.Message + " (" + head.GetType().NormalizeName() + ")", ex.InnerException);
				}
			}
			return compiledSerializer;
		}

		protected CompiledSerializer(IProtoTypeSerializer head)
		{
			this.head = head;
		}

		public abstract void Write(ref ProtoWriter.State state, object value);

		public abstract object Read(ref ProtoReader.State state, object value);

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			head.EmitWrite(ctx, valueFrom);
		}

		void IProtoTypeSerializer.EmitWriteRoot(CompilerContext ctx, Local valueFrom)
		{
			head.EmitWriteRoot(ctx, valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local valueFrom)
		{
			head.EmitRead(ctx, valueFrom);
		}

		void IProtoTypeSerializer.EmitReadRoot(CompilerContext ctx, Local valueFrom)
		{
			head.EmitReadRoot(ctx, valueFrom);
		}

		void IProtoTypeSerializer.EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
			head.EmitCallback(ctx, valueFrom, callbackType);
		}

		void IProtoTypeSerializer.EmitCreateInstance(CompilerContext ctx, bool callNoteObject)
		{
			head.EmitCreateInstance(ctx, callNoteObject);
		}
	}
	internal sealed class DateTimeSerializer : IRuntimeProtoSerializerNode
	{
		private static readonly Type expectedType = typeof(DateTime);

		private static DateTimeSerializer s_Timestamp;

		private readonly bool _includeKind;

		private readonly bool _useTimestamp;

		bool IRuntimeProtoSerializerNode.IsScalar => false;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public static DateTimeSerializer Create(CompatibilityLevel compatibilityLevel, TypeModel model)
		{
			if (compatibilityLevel < CompatibilityLevel.Level240)
			{
				return new DateTimeSerializer(useTimestamp: false, model.HasOption(TypeModel.TypeModelOptions.IncludeDateTimeKind));
			}
			return s_Timestamp ?? (s_Timestamp = new DateTimeSerializer(useTimestamp: true, includeKind: false));
		}

		private DateTimeSerializer(bool useTimestamp, bool includeKind)
		{
			_useTimestamp = useTimestamp;
			_includeKind = includeKind;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			if (_useTimestamp)
			{
				return BclHelpers.ReadTimestamp(ref state);
			}
			return BclHelpers.ReadDateTime(ref state);
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			if (_useTimestamp)
			{
				BclHelpers.WriteTimestamp(ref state, (DateTime)value);
			}
			else if (_includeKind)
			{
				BclHelpers.WriteDateTimeWithKind(ref state, (DateTime)value);
			}
			else
			{
				BclHelpers.WriteDateTime(ref state, (DateTime)value);
			}
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite(_useTimestamp ? "WriteTimestamp" : (_includeKind ? "WriteDateTimeWithKind" : "WriteDateTime"), valueFrom, typeof(BclHelpers));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			if (_useTimestamp)
			{
				ctx.LoadValue(entity);
			}
			ctx.EmitStateBasedRead(typeof(BclHelpers), _useTimestamp ? "ReadTimestamp" : "ReadDateTime", ExpectedType);
		}
	}
	internal sealed class DecimalSerializer : IRuntimeProtoSerializerNode
	{
		private enum Variant
		{
			BclDecimal,
			String
		}

		private static DecimalSerializer s_BclDecimal;

		private static DecimalSerializer s_String;

		private readonly Variant _variant;

		private static readonly Type expectedType = typeof(decimal);

		bool IRuntimeProtoSerializerNode.IsScalar => _variant == Variant.String;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public static DecimalSerializer Create(CompatibilityLevel compatibilityLevel)
		{
			if (compatibilityLevel < CompatibilityLevel.Level300)
			{
				return s_BclDecimal ?? (s_BclDecimal = new DecimalSerializer(Variant.BclDecimal));
			}
			return s_String ?? (s_String = new DecimalSerializer(Variant.String));
		}

		private DecimalSerializer(Variant variant)
		{
			_variant = variant;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			Variant variant = _variant;
			decimal num = ((variant != Variant.String) ? BclHelpers.ReadDecimal(ref state) : BclHelpers.ReadDecimalString(ref state));
			return num;
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			Variant variant = _variant;
			if (variant == Variant.String)
			{
				BclHelpers.WriteDecimalString(ref state, (decimal)value);
			}
			else
			{
				BclHelpers.WriteDecimal(ref state, (decimal)value);
			}
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			Variant variant = _variant;
			string methodName = ((variant != Variant.String) ? "WriteDecimal" : "WriteDecimalString");
			ctx.EmitStateBasedWrite(methodName, valueFrom, typeof(BclHelpers));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			Type typeFromHandle = typeof(BclHelpers);
			Variant variant = _variant;
			string methodName = ((variant != Variant.String) ? "ReadDecimal" : "ReadDecimalString");
			ctx.EmitStateBasedRead(typeFromHandle, methodName, ExpectedType);
		}
	}
	internal sealed class DefaultValueDecorator : ProtoDecoratorBase
	{
		private readonly object defaultValue;

		public override Type ExpectedType => Tail.ExpectedType;

		public override bool RequiresOldValue => Tail.RequiresOldValue;

		public override bool ReturnsValue => Tail.ReturnsValue;

		public DefaultValueDecorator(object defaultValue, IRuntimeProtoSerializerNode tail)
			: base(tail)
		{
			if (defaultValue == null)
			{
				throw new ArgumentNullException("defaultValue");
			}
			Type type = defaultValue.GetType();
			if (type != tail.ExpectedType)
			{
				throw new ArgumentException("Default value is of incorrect type", "defaultValue");
			}
			this.defaultValue = defaultValue;
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			if (!object.Equals(value, defaultValue))
			{
				Tail.Write(ref state, value);
			}
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			return Tail.Read(ref state, value);
		}

		protected override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			CodeLabel label = ctx.DefineLabel();
			using (Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom))
			{
				ctx.LoadValue(local);
				EmitBranchIfDefaultValue(ctx, label);
				Tail.EmitWrite(ctx, local);
			}
			ctx.MarkLabel(label);
		}

		private static void EmitBeq(CompilerContext ctx, CodeLabel label, Type type)
		{
			ProtoTypeCode typeCode = Helpers.GetTypeCode(type);
			if ((uint)(typeCode - 3) <= 11u)
			{
				ctx.BranchIfEqual(label, @short: false);
				return;
			}
			MethodInfo method = type.GetMethod("op_Equality", BindingFlags.Static | BindingFlags.Public, null, new Type[2] { type, type }, null);
			if ((object)method == null || method.ReturnType != typeof(bool))
			{
				throw new InvalidOperationException("No suitable equality operator found for default-values of type: " + type.FullName);
			}
			ctx.EmitCall(method);
			ctx.BranchIfTrue(label, @short: false);
		}

		private void EmitBranchIfDefaultValue(CompilerContext ctx, CodeLabel label)
		{
			Type expectedType = ExpectedType;
			switch (Helpers.GetTypeCode(expectedType))
			{
			case ProtoTypeCode.Boolean:
				if ((bool)defaultValue)
				{
					ctx.BranchIfTrue(label, @short: false);
				}
				else
				{
					ctx.BranchIfFalse(label, @short: false);
				}
				break;
			case ProtoTypeCode.Byte:
				if ((byte)defaultValue == 0)
				{
					ctx.BranchIfFalse(label, @short: false);
					break;
				}
				ctx.LoadValue((byte)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.SByte:
				if ((sbyte)defaultValue == 0)
				{
					ctx.BranchIfFalse(label, @short: false);
					break;
				}
				ctx.LoadValue((sbyte)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.Int16:
				if ((short)defaultValue == 0)
				{
					ctx.BranchIfFalse(label, @short: false);
					break;
				}
				ctx.LoadValue((short)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.UInt16:
				if ((ushort)defaultValue == 0)
				{
					ctx.BranchIfFalse(label, @short: false);
					break;
				}
				ctx.LoadValue((ushort)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.Int32:
				if ((int)defaultValue == 0)
				{
					ctx.BranchIfFalse(label, @short: false);
					break;
				}
				ctx.LoadValue((int)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.UInt32:
				if ((uint)defaultValue == 0)
				{
					ctx.BranchIfFalse(label, @short: false);
					break;
				}
				ctx.LoadValue((int)(uint)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.Char:
				if ((char)defaultValue == '\0')
				{
					ctx.BranchIfFalse(label, @short: false);
					break;
				}
				ctx.LoadValue((char)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.Int64:
				ctx.LoadValue((long)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.UInt64:
				ctx.LoadValue((ulong)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.Double:
				ctx.LoadValue((double)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.Single:
				ctx.LoadValue((float)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.String:
				ctx.LoadValue((string)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.Decimal:
			{
				decimal value = (decimal)defaultValue;
				ctx.LoadValue(value);
				EmitBeq(ctx, label, expectedType);
				break;
			}
			case ProtoTypeCode.TimeSpan:
			{
				TimeSpan timeSpan = (TimeSpan)defaultValue;
				if (timeSpan == TimeSpan.Zero)
				{
					ctx.LoadValue(typeof(TimeSpan).GetField("Zero"));
				}
				else
				{
					ctx.LoadValue(timeSpan.Ticks);
					ctx.EmitCall(typeof(TimeSpan).GetMethod("FromTicks"));
				}
				EmitBeq(ctx, label, expectedType);
				break;
			}
			case ProtoTypeCode.Guid:
				ctx.LoadValue((Guid)defaultValue);
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.DateTime:
				ctx.LoadValue(((DateTime)defaultValue).ToBinary());
				ctx.EmitCall(typeof(DateTime).GetMethod("FromBinary"));
				EmitBeq(ctx, label, expectedType);
				break;
			case ProtoTypeCode.IntPtr:
				ctx.Emit(OpCodes.Conv_I8);
				ctx.LoadValue(((IntPtr)defaultValue).ToInt64());
				EmitBeq(ctx, label, typeof(long));
				break;
			case ProtoTypeCode.UIntPtr:
				ctx.Emit(OpCodes.Conv_U8);
				ctx.LoadValue(((UIntPtr)defaultValue).ToUInt64());
				EmitBeq(ctx, label, typeof(ulong));
				break;
			default:
				throw new NotSupportedException("Type cannot be represented as a default value: " + expectedType.FullName);
			}
		}

		protected override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			Tail.EmitRead(ctx, valueFrom);
		}
	}
	internal sealed class DoubleSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly DoubleSerializer Instance = new DoubleSerializer();

		private static readonly Type expectedType = typeof(double);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private DoubleSerializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadDouble();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteDouble((double)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteDouble", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadDouble", ExpectedType);
		}
	}
	internal class EnumMemberSerializer : IRuntimeProtoSerializerNode, IDirectWriteNode
	{
		private readonly IRuntimeProtoSerializerNode _tail;

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType { get; }

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public EnumMemberSerializer(Type enumType)
		{
			ExpectedType = enumType ?? throw new ArgumentNullException("enumType");
			if (!enumType.IsEnum)
			{
				ThrowHelper.ThrowInvalidOperationException("Expected an enum type; got " + enumType.NormalizeName());
			}
			_tail = Type.GetTypeCode(enumType) switch
			{
				TypeCode.SByte => SByteSerializer.Instance, 
				TypeCode.Int16 => Int16Serializer.Instance, 
				TypeCode.Int32 => Int32Serializer.Instance, 
				TypeCode.Int64 => Int64Serializer.Instance, 
				TypeCode.Byte => ByteSerializer.Instance, 
				TypeCode.UInt16 => UInt16Serializer.Instance, 
				TypeCode.UInt32 => UInt32Serializer.Instance, 
				TypeCode.UInt64 => UInt64Serializer.Instance, 
				_ => null, 
			};
			if (_tail == null)
			{
				ThrowHelper.ThrowInvalidOperationException("Unable to resolve underlying enum type for " + enumType.NormalizeName());
			}
		}

		internal static object EnumToWire(object value, Type type)
		{
			return Type.GetTypeCode(type) switch
			{
				TypeCode.Byte => (byte)value, 
				TypeCode.SByte => (sbyte)value, 
				TypeCode.Int16 => (short)value, 
				TypeCode.Int32 => (int)value, 
				TypeCode.Int64 => (long)value, 
				TypeCode.UInt16 => (ushort)value, 
				TypeCode.UInt32 => (uint)value, 
				TypeCode.UInt64 => (ulong)value, 
				_ => throw new InvalidOperationException(), 
			};
		}

		private object EnumToWire(object value)
		{
			return EnumToWire(value, ExpectedType);
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return Enum.ToObject(ExpectedType, _tail.Read(ref state, value));
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			_tail.Write(ref state, EnumToWire(value));
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			_tail.EmitWrite(ctx, valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			_tail.EmitRead(ctx, entity);
		}

		bool IDirectWriteNode.CanEmitDirectWrite(WireType wireType)
		{
			if (_tail is IDirectWriteNode directWriteNode)
			{
				return directWriteNode.CanEmitDirectWrite(wireType);
			}
			return false;
		}

		void IDirectWriteNode.EmitDirectWrite(int fieldNumber, WireType wireType, CompilerContext ctx, Local valueFrom)
		{
			((IDirectWriteNode)_tail).EmitDirectWrite(fieldNumber, wireType, ctx, valueFrom);
		}
	}
	internal class ExternalSerializer
	{
		internal static IProtoTypeSerializer Create(Type target, Type serializer)
		{
			return (IProtoTypeSerializer)Activator.CreateInstance(typeof(ExternalSerializer<, >).MakeGenericType(serializer, target), nonPublic: true);
		}
	}
	internal interface IExternalSerializer
	{
		object Service { get; }
	}
	internal sealed class ExternalSerializer<TProvider, T> : IRuntimeProtoSerializerNode, IExternalSerializer, ICompiledSerializer, IProtoTypeSerializer where TProvider : class
	{
		object IExternalSerializer.Service => Serializer;

		private static ISerializer<T> Serializer => SerializerCache<TProvider, T>.InstanceField;

		public Type ExpectedType => typeof(T);

		bool IRuntimeProtoSerializerNode.RequiresOldValue => true;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		SerializerFeatures IProtoTypeSerializer.Features => Serializer.Features;

		bool IRuntimeProtoSerializerNode.IsScalar => Serializer.Features.IsScalar();

		Type IProtoTypeSerializer.BaseType => ExpectedType;

		bool IProtoTypeSerializer.ShouldEmitCreateInstance => false;

		bool IProtoTypeSerializer.HasInheritance => false;

		bool IProtoTypeSerializer.IsSubType => false;

		void IRuntimeProtoSerializerNode.Write(ref ProtoWriter.State state, object value)
		{
			Serializer.Write(ref state, TypeHelper<T>.FromObject(value));
		}

		object IRuntimeProtoSerializerNode.Read(ref ProtoReader.State state, object value)
		{
			return Serializer.Read(ref state, TypeHelper<T>.FromObject(value));
		}

		bool IProtoTypeSerializer.CanCreateInstance()
		{
			return Serializer is IFactory<T>;
		}

		object IProtoTypeSerializer.CreateInstance(ISerializationContext context)
		{
			if (Serializer is IFactory<T> factory)
			{
				return factory.Create(context);
			}
			return null;
		}

		void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
		}

		bool IProtoTypeSerializer.HasCallbacks(TypeModel.CallbackType callbackType)
		{
			return false;
		}

		void IProtoTypeSerializer.EmitCreateInstance(CompilerContext ctx, bool callNoteObject)
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		void IProtoTypeSerializer.EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		void IProtoTypeSerializer.EmitReadRoot(CompilerContext ctx, Local entity)
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		void IProtoTypeSerializer.EmitWriteRoot(CompilerContext ctx, Local entity)
		{
			ThrowHelper.ThrowNotSupportedException();
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(T), valueFrom);
			if (ctx.NonPublic || RuntimeTypeModel.IsFullyPublic(typeof(TProvider)))
			{
				ctx.EmitCall(typeof(SerializerCache).GetMethod("Get").MakeGenericMethod(typeof(TProvider), typeof(T)));
			}
			else
			{
				ctx.LoadState();
				ctx.EmitCall(typeof(ProtoWriter.State).GetMethod("GetSerializer").MakeGenericMethod(typeof(T)));
			}
			ctx.LoadState();
			ctx.LoadValue(local);
			ctx.EmitCall(typeof(ISerializer<T>).GetMethod("Write"));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			using Local local = ctx.GetLocalWithValue(typeof(T), entity);
			if (ctx.NonPublic || RuntimeTypeModel.IsFullyPublic(typeof(TProvider)))
			{
				ctx.EmitCall(typeof(SerializerCache).GetMethod("Get").MakeGenericMethod(typeof(TProvider), typeof(T)));
			}
			else
			{
				ctx.LoadState();
				ctx.EmitCall(typeof(ProtoReader.State).GetMethod("GetSerializer").MakeGenericMethod(typeof(T)));
			}
			ctx.LoadState();
			ctx.LoadValue(local);
			ctx.EmitCall(typeof(ISerializer<T>).GetMethod("Read"));
			ctx.StoreValue(entity);
		}
	}
	internal sealed class FieldDecorator : ProtoDecoratorBase
	{
		private readonly FieldInfo field;

		public override Type ExpectedType { get; }

		public override bool RequiresOldValue => true;

		public override bool ReturnsValue => false;

		public FieldDecorator(Type forType, FieldInfo field, IRuntimeProtoSerializerNode tail)
			: base(tail)
		{
			if (tail == null)
			{
				ThrowHelper.ThrowArgumentNullException("tail");
			}
			if ((object)field == null)
			{
				ThrowHelper.ThrowArgumentNullException("field");
			}
			if ((object)forType == null)
			{
				ThrowHelper.ThrowArgumentNullException("forType");
			}
			ExpectedType = forType;
			this.field = field;
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			value = field.GetValue(value);
			if (value != null)
			{
				Tail.Write(ref state, value);
			}
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			object obj = Tail.Read(ref state, Tail.RequiresOldValue ? field.GetValue(value) : null);
			if (obj != null)
			{
				field.SetValue(value, obj);
			}
			return null;
		}

		protected override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.LoadAddress(valueFrom, ExpectedType);
			ctx.LoadValue(field);
			ctx.WriteNullCheckedTail(field.FieldType, Tail, null);
		}

		protected override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			if (Tail.RequiresOldValue)
			{
				ctx.LoadAddress(local, ExpectedType);
				ctx.LoadValue(field);
			}
			ctx.ReadNullCheckedTail(field.FieldType, Tail, null);
			MemberInfo member = field;
			ctx.CheckAccessibility(ref member);
			if (member is FieldInfo)
			{
				if (!Tail.ReturnsValue)
				{
					return;
				}
				Type type = PropertyDecorator.ChooseReadLocalType(field.FieldType, Tail.ExpectedType);
				using Local local2 = new Local(ctx, type);
				ctx.StoreValue(local2);
				if (field.FieldType.IsValueType)
				{
					ctx.LoadAddress(local, ExpectedType);
					ctx.LoadValue(local2);
					ctx.StoreValue(field);
					return;
				}
				CodeLabel label = ctx.DefineLabel();
				ctx.LoadValue(local2);
				ctx.BranchIfFalse(label, @short: true);
				ctx.LoadAddress(local, ExpectedType);
				ctx.LoadValue(local2);
				if (!field.FieldType.IsValueType && !type.IsValueType && !field.FieldType.IsAssignableFrom(type))
				{
					ctx.Cast(field.FieldType);
				}
				ctx.StoreValue(field);
				ctx.MarkLabel(label);
				return;
			}
			if (Tail.ReturnsValue)
			{
				ctx.DiscardValue();
			}
		}
	}
	internal sealed class GuidSerializer : IRuntimeProtoSerializerNode
	{
		private enum Variant
		{
			BclGuid,
			GuidString,
			GuidBytes
		}

		private readonly Variant _variant;

		private static GuidSerializer s_Legacy;

		private static GuidSerializer s_String;

		private static GuidSerializer s_Bytes;

		private static readonly Type expectedType = typeof(Guid);

		bool IRuntimeProtoSerializerNode.IsScalar => _variant switch
		{
			Variant.GuidString => true, 
			Variant.GuidBytes => true, 
			_ => false, 
		};

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		internal static GuidSerializer Create(CompatibilityLevel compatibilityLevel, DataFormat dataFormat)
		{
			if (compatibilityLevel < CompatibilityLevel.Level300)
			{
				return s_Legacy ?? (s_Legacy = new GuidSerializer(Variant.BclGuid));
			}
			if (dataFormat == DataFormat.FixedSize)
			{
				return s_Bytes ?? (s_Bytes = new GuidSerializer(Variant.GuidBytes));
			}
			return s_String ?? (s_String = new GuidSerializer(Variant.GuidString));
		}

		private GuidSerializer(Variant variant)
		{
			_variant = variant;
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			switch (_variant)
			{
			case Variant.GuidString:
				BclHelpers.WriteGuidString(ref state, (Guid)value);
				break;
			case Variant.GuidBytes:
				BclHelpers.WriteGuidBytes(ref state, (Guid)value);
				break;
			default:
				BclHelpers.WriteGuid(ref state, (Guid)value);
				break;
			}
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return _variant switch
			{
				Variant.GuidString => BclHelpers.ReadGuidString(ref state), 
				Variant.GuidBytes => BclHelpers.ReadGuidBytes(ref state), 
				_ => BclHelpers.ReadGuid(ref state), 
			};
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite(_variant switch
			{
				Variant.GuidString => "WriteGuidString", 
				Variant.GuidBytes => "WriteGuidBytes", 
				_ => "WriteGuid", 
			}, valueFrom, typeof(BclHelpers));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			Type typeFromHandle = typeof(BclHelpers);
			ctx.EmitStateBasedRead(typeFromHandle, _variant switch
			{
				Variant.GuidString => "ReadGuidString", 
				Variant.GuidBytes => "ReadGuidBytes", 
				_ => "ReadGuid", 
			}, ExpectedType);
		}
	}
	internal interface IDirectWriteNode
	{
		bool CanEmitDirectWrite(WireType wireType);

		void EmitDirectWrite(int fieldNumber, WireType wireType, CompilerContext ctx, Local valueFrom);
	}
	internal interface IDirectRuntimeWriteNode
	{
		bool CanDirectWrite(WireType wireType);

		void DirectWrite(int fieldNumber, WireType wireType, ref ProtoWriter.State state, object value);
	}
	internal sealed class Int16Serializer : IRuntimeProtoSerializerNode
	{
		internal static readonly Int16Serializer Instance = new Int16Serializer();

		private static readonly Type expectedType = typeof(short);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private Int16Serializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadInt16();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteInt16((short)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteInt16", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadInt16", ExpectedType);
		}
	}
	internal sealed class Int32Serializer : IRuntimeProtoSerializerNode, IDirectWriteNode
	{
		internal static readonly Int32Serializer Instance = new Int32Serializer();

		private static readonly Type expectedType = typeof(int);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private Int32Serializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadInt32();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteInt32((int)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteInt32", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadInt32", ExpectedType);
		}

		bool IDirectWriteNode.CanEmitDirectWrite(WireType wireType)
		{
			return wireType == WireType.Variant;
		}

		void IDirectWriteNode.EmitDirectWrite(int fieldNumber, WireType wireType, CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(int), valueFrom);
			ctx.LoadState();
			ctx.LoadValue(fieldNumber);
			ctx.LoadValue(local);
			ctx.EmitCall(typeof(ProtoWriter.State).GetMethod("WriteInt32Varint", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
			{
				typeof(int),
				typeof(int)
			}, null));
		}
	}
	internal sealed class Int64Serializer : IRuntimeProtoSerializerNode
	{
		internal static readonly Int64Serializer Instance = new Int64Serializer();

		private static readonly Type expectedType = typeof(long);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private Int64Serializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadInt64();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteInt64((long)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteInt64", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadInt64", ExpectedType);
		}
	}
	internal sealed class IntPtrSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly IntPtrSerializer Instance = new IntPtrSerializer();

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => typeof(IntPtr);

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private IntPtrSerializer()
		{
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteIntPtr((IntPtr)value);
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadIntPtr();
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteIntPtr", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadIntPtr", ExpectedType);
		}
	}
	internal interface IRuntimeProtoSerializerNode
	{
		bool IsScalar { get; }

		Type ExpectedType { get; }

		bool RequiresOldValue { get; }

		bool ReturnsValue { get; }

		void Write(ref ProtoWriter.State state, object value);

		object Read(ref ProtoReader.State state, object value);

		void EmitWrite(CompilerContext ctx, Local valueFrom);

		void EmitRead(CompilerContext ctx, Local entity);
	}
	internal interface IProtoTypeSerializer : IRuntimeProtoSerializerNode
	{
		Type BaseType { get; }

		bool ShouldEmitCreateInstance { get; }

		bool HasInheritance { get; }

		bool IsSubType { get; }

		SerializerFeatures Features { get; }

		bool HasCallbacks(TypeModel.CallbackType callbackType);

		bool CanCreateInstance();

		object CreateInstance(ISerializationContext context);

		void Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context);

		void EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType);

		void EmitCreateInstance(CompilerContext ctx, bool callNoteObject = true);

		void EmitReadRoot(CompilerContext ctx, Local entity);

		void EmitWriteRoot(CompilerContext ctx, Local entity);
	}
	internal interface ISerializerProxy
	{
		IRuntimeProtoSerializerNode Serializer { get; }
	}
	internal static class MapDecorator
	{
		public static IRuntimeProtoSerializerNode Create(RepeatedSerializerStub provider, Type keyType, Type valueType, int fieldNumber, SerializerFeatures features, SerializerFeatures keyFeatures, CompatibilityLevel keyCompatibilityLevel, DataFormat keyDataFormat, SerializerFeatures valueFeatures, CompatibilityLevel valueCompatibilityLevel, DataFormat valueDataFormat)
		{
			if (provider == null)
			{
				ThrowHelper.ThrowArgumentNullException("provider");
			}
			_ = provider.Serializer;
			return (IRuntimeProtoSerializerNode)Activator.CreateInstance(typeof(MapDecorator<, , >).MakeGenericType(provider.ForType, keyType, valueType), fieldNumber, features, keyFeatures, keyCompatibilityLevel, keyDataFormat, valueFeatures, valueCompatibilityLevel, valueDataFormat, provider);
		}
	}
	internal class MapDecorator<TCollection, TKey, TValue> : IRuntimeProtoSerializerNode, ICompiledSerializer
	{
		private readonly int _fieldNumber;

		private readonly SerializerFeatures _features;

		private readonly SerializerFeatures _keyFeatures;

		private readonly SerializerFeatures _valueFeatures;

		private readonly CompatibilityLevel _keyCompatibilityLevel;

		private readonly CompatibilityLevel _valueCompatibilityLevel;

		private readonly DataFormat _keyDataFormat;

		private readonly DataFormat _valueDataFormat;

		private readonly RepeatedSerializerStub _provider;

		bool IRuntimeProtoSerializerNode.IsScalar => false;

		private MapSerializer<TCollection, TKey, TValue> Serializer => (MapSerializer<TCollection, TKey, TValue>)_provider.Serializer;

		public Type ExpectedType => typeof(TCollection);

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public bool RequiresOldValue => true;

		public MapDecorator(int fieldNumber, SerializerFeatures features, SerializerFeatures keyFeatures, CompatibilityLevel keyCompatibilityLevel, DataFormat keyDataFormat, SerializerFeatures valueFeatures, CompatibilityLevel valueCompatibilityLevel, DataFormat valueDataFormat, RepeatedSerializerStub provider)
		{
			_provider = provider;
			_features = features;
			_keyFeatures = keyFeatures;
			_keyCompatibilityLevel = keyCompatibilityLevel;
			_keyDataFormat = keyDataFormat;
			_valueFeatures = valueFeatures;
			_valueCompatibilityLevel = valueCompatibilityLevel;
			_valueDataFormat = valueDataFormat;
			_fieldNumber = fieldNumber;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return Serializer.ReadMap(ref state, _features, (TCollection)value, _keyFeatures, _valueFeatures, TypeModel.GetInbuiltSerializer<TKey>(_keyCompatibilityLevel, _keyDataFormat), TypeModel.GetInbuiltSerializer<TValue>(_valueCompatibilityLevel, _valueDataFormat));
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			Serializer.WriteMap(ref state, _fieldNumber, _features, (TCollection)value, _keyFeatures, _valueFeatures, TypeModel.GetInbuiltSerializer<TKey>(_keyCompatibilityLevel, _keyDataFormat), TypeModel.GetInbuiltSerializer<TValue>(_valueCompatibilityLevel, _valueDataFormat));
		}

		public void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			_ = Serializer;
			MethodInfo method = typeof(MapSerializer<TCollection, TKey, TValue>).GetMethod("WriteMap");
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			_provider.EmitProvider(ctx);
			ctx.LoadState();
			ctx.LoadValue(_fieldNumber);
			ctx.LoadValue((int)_features);
			ctx.LoadValue(local);
			ctx.LoadValue((int)_keyFeatures);
			ctx.LoadValue((int)_valueFeatures);
			ctx.LoadSelfAsService<ISerializer<TKey>, TKey>(_keyCompatibilityLevel, _keyDataFormat);
			ctx.LoadSelfAsService<ISerializer<TValue>, TValue>(_valueCompatibilityLevel, _valueDataFormat);
			ctx.EmitCall(method);
		}

		public void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			MethodInfo method = typeof(MapSerializer<TCollection, TKey, TValue>).GetMethod("ReadMap");
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			_provider.EmitProvider(ctx);
			ctx.LoadState();
			ctx.LoadValue((int)_features);
			ctx.LoadValue(local);
			ctx.LoadValue((int)_keyFeatures);
			ctx.LoadValue((int)_valueFeatures);
			ctx.LoadSelfAsService<ISerializer<TKey>, TKey>(_keyCompatibilityLevel, _keyDataFormat);
			ctx.LoadSelfAsService<ISerializer<TValue>, TValue>(_valueCompatibilityLevel, _valueDataFormat);
			ctx.EmitCall(method);
		}
	}
	internal sealed class MemberSpecifiedDecorator : ProtoDecoratorBase
	{
		private readonly MethodInfo getSpecified;

		private readonly MethodInfo setSpecified;

		public override Type ExpectedType => Tail.ExpectedType;

		public override bool RequiresOldValue => Tail.RequiresOldValue;

		public override bool ReturnsValue => Tail.ReturnsValue;

		public MemberSpecifiedDecorator(MethodInfo getSpecified, MethodInfo setSpecified, IRuntimeProtoSerializerNode tail)
			: base(tail)
		{
			if ((object)getSpecified == null && (object)setSpecified == null)
			{
				throw new InvalidOperationException();
			}
			this.getSpecified = getSpecified;
			this.setSpecified = setSpecified;
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			if ((object)getSpecified == null || (bool)getSpecified.Invoke(value, null))
			{
				Tail.Write(ref state, value);
			}
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			object result = Tail.Read(ref state, value);
			if ((object)setSpecified != null)
			{
				setSpecified.Invoke(value, new object[1] { true });
			}
			return result;
		}

		protected override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			if ((object)getSpecified == null)
			{
				Tail.EmitWrite(ctx, valueFrom);
				return;
			}
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			ctx.LoadAddress(local, ExpectedType);
			ctx.EmitCall(getSpecified);
			CodeLabel label = ctx.DefineLabel();
			ctx.BranchIfFalse(label, @short: false);
			Tail.EmitWrite(ctx, local);
			ctx.MarkLabel(label);
		}

		protected override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			if ((object)setSpecified == null)
			{
				Tail.EmitRead(ctx, valueFrom);
				return;
			}
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			Tail.EmitRead(ctx, local);
			ctx.LoadAddress(local, ExpectedType);
			ctx.LoadValue(1);
			ctx.EmitCall(setSpecified);
		}
	}
	internal sealed class ParseableSerializer : IRuntimeProtoSerializerNode
	{
		private readonly MethodInfo parse;

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => parse.DeclaringType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public static ParseableSerializer TryCreate(Type type)
		{
			if ((object)type == null)
			{
				throw new ArgumentNullException("type");
			}
			MethodInfo method = type.GetMethod("Parse", BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public, null, new Type[1] { typeof(string) }, null);
			if ((object)method != null && method.ReturnType == type)
			{
				if (type.IsValueType)
				{
					MethodInfo customToString = GetCustomToString(type);
					if ((object)customToString == null || customToString.ReturnType != typeof(string))
					{
						return null;
					}
				}
				return new ParseableSerializer(method);
			}
			return null;
		}

		private static MethodInfo GetCustomToString(Type type)
		{
			return type.GetMethod("ToString", BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public, null, Type.EmptyTypes, null);
		}

		private ParseableSerializer(MethodInfo parse)
		{
			this.parse = parse;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return parse.Invoke(null, new object[1] { state.ReadString() });
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteString(value.ToString());
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			Type expectedType = ExpectedType;
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			ctx.LoadState();
			ctx.LoadAddress(local, expectedType);
			if (expectedType.IsValueType)
			{
				ctx.EmitCall(GetCustomToString(expectedType));
			}
			else
			{
				ctx.EmitCall(typeof(object).GetMethod("ToString"));
			}
			ctx.LoadNullRef();
			ctx.EmitCall(typeof(ProtoWriter.State).GetMethod("WriteString", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
			{
				typeof(string),
				typeof(StringMap)
			}, null));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.LoadState();
			ctx.LoadNullRef();
			ctx.EmitCall(typeof(ProtoReader.State).GetMethod("ReadString", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(StringMap) }, null));
			ctx.EmitCall(parse);
		}
	}
	internal sealed class PropertyDecorator : ProtoDecoratorBase
	{
		private readonly PropertyInfo property;

		private readonly bool readOptionsWriteValue;

		private readonly MethodInfo shadowSetter;

		public override Type ExpectedType { get; }

		public override bool RequiresOldValue => true;

		public override bool ReturnsValue => false;

		public PropertyDecorator(Type forType, PropertyInfo property, IRuntimeProtoSerializerNode tail)
			: base(tail)
		{
			if (tail == null)
			{
				ThrowHelper.ThrowArgumentNullException("tail");
			}
			if ((object)property == null)
			{
				ThrowHelper.ThrowArgumentNullException("property");
			}
			if ((object)forType == null)
			{
				ThrowHelper.ThrowArgumentNullException("forType");
			}
			ExpectedType = forType;
			this.property = property;
			SanityCheck(property, tail, out readOptionsWriteValue, nonPublic: true, allowInternal: true);
			shadowSetter = GetShadowSetter(property);
		}

		private static void SanityCheck(PropertyInfo property, IRuntimeProtoSerializerNode tail, out bool writeValue, bool nonPublic, bool allowInternal)
		{
			if ((object)property == null)
			{
				throw new ArgumentNullException("property");
			}
			writeValue = tail.ReturnsValue && ((object)GetShadowSetter(property) != null || (property.CanWrite && (object)Helpers.GetSetMethod(property, nonPublic, allowInternal) != null));
			if (!property.CanRead || (object)Helpers.GetGetMethod(property, nonPublic, allowInternal) == null)
			{
				throw new InvalidOperationException("Cannot serialize property without an accessible get accessor: " + property.DeclaringType.FullName + "." + property.Name);
			}
			if (!writeValue && (!tail.RequiresOldValue || tail.ExpectedType.IsValueType))
			{
				throw new InvalidOperationException("Cannot apply changes to property " + property.DeclaringType.FullName + "." + property.Name);
			}
		}

		private static MethodInfo GetShadowSetter(PropertyInfo property)
		{
			Type reflectedType = property.ReflectedType;
			MethodInfo instanceMethod = Helpers.GetInstanceMethod(reflectedType, "Set" + property.Name, new Type[1] { property.PropertyType });
			if ((object)instanceMethod == null || !instanceMethod.IsPublic || instanceMethod.ReturnType != typeof(void))
			{
				return null;
			}
			return instanceMethod;
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			value = property.GetValue(value, null);
			if (value != null)
			{
				Tail.Write(ref state, value);
			}
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			object value2 = (Tail.RequiresOldValue ? property.GetValue(value, null) : null);
			object obj = Tail.Read(ref state, value2);
			if (readOptionsWriteValue && obj != null)
			{
				if ((object)shadowSetter == null)
				{
					property.SetValue(value, obj, null);
				}
				else
				{
					shadowSetter.Invoke(value, new object[1] { obj });
				}
			}
			return null;
		}

		protected override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.LoadAddress(valueFrom, ExpectedType);
			ctx.LoadValue(property);
			ctx.WriteNullCheckedTail(property.PropertyType, Tail, null);
		}

		internal static Type ChooseReadLocalType(Type memberType, Type tailType)
		{
			if (memberType == tailType)
			{
				return memberType;
			}
			if (memberType.IsClass && tailType.IsClass)
			{
				return tailType;
			}
			if (memberType.IsValueType && tailType.IsValueType && tailType == Nullable.GetUnderlyingType(memberType))
			{
				return memberType;
			}
			return tailType;
		}

		protected override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			SanityCheck(property, Tail, out var writeValue, ctx.NonPublic, ctx.AllowInternal(property));
			if (ExpectedType.IsValueType && valueFrom == null)
			{
				throw new InvalidOperationException("Attempt to mutate struct on the head of the stack; changes would be lost");
			}
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			if (Tail.RequiresOldValue)
			{
				ctx.LoadAddress(local, ExpectedType);
				ctx.LoadValue(property);
			}
			Type propertyType = property.PropertyType;
			ctx.ReadNullCheckedTail(propertyType, Tail, null);
			if (writeValue)
			{
				Type type = ChooseReadLocalType(property.PropertyType, Tail.ExpectedType);
				using Local local2 = new Local(ctx, type);
				ctx.StoreValue(local2);
				CodeLabel label = default(CodeLabel);
				if (!type.IsValueType)
				{
					label = ctx.DefineLabel();
					ctx.LoadValue(local2);
					ctx.BranchIfFalse(label, @short: true);
				}
				ctx.LoadAddress(local, ExpectedType);
				ctx.LoadValue(local2);
				if (!property.PropertyType.IsValueType && !type.IsValueType && !property.PropertyType.IsAssignableFrom(type))
				{
					ctx.Cast(property.PropertyType);
				}
				if ((object)shadowSetter == null)
				{
					ctx.StoreValue(property);
				}
				else
				{
					ctx.EmitCall(shadowSetter);
				}
				if (!propertyType.IsValueType)
				{
					ctx.MarkLabel(label);
				}
				return;
			}
			if (Tail.ReturnsValue)
			{
				ctx.DiscardValue();
			}
		}
	}
	internal abstract class ProtoDecoratorBase : IRuntimeProtoSerializerNode
	{
		protected readonly IRuntimeProtoSerializerNode Tail;

		public virtual bool IsScalar => Tail.IsScalar;

		public abstract Type ExpectedType { get; }

		public abstract bool ReturnsValue { get; }

		public abstract bool RequiresOldValue { get; }

		protected ProtoDecoratorBase(IRuntimeProtoSerializerNode tail)
		{
			Tail = tail;
		}

		public abstract void Write(ref ProtoWriter.State state, object value);

		public abstract object Read(ref ProtoReader.State state, object value);

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			EmitWrite(ctx, valueFrom);
		}

		protected abstract void EmitWrite(CompilerContext ctx, Local valueFrom);

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			EmitRead(ctx, entity);
		}

		protected abstract void EmitRead(CompilerContext ctx, Local valueFrom);
	}
	internal static class RepeatedDecorator
	{
		public static IRuntimeProtoSerializerNode Create(RepeatedSerializerStub stub, int fieldNumber, SerializerFeatures features, CompatibilityLevel compatibilityLevel, DataFormat dataFormat)
		{
			if (stub == null)
			{
				ThrowHelper.ThrowArgumentNullException("stub", "No suitable repeated serializer resolved for " + stub.ForType.NormalizeName());
			}
			_ = stub.Serializer;
			return (IRuntimeProtoSerializerNode)Activator.CreateInstance(typeof(RepeatedDecorator<, >).MakeGenericType(stub.ForType, stub.ItemType), fieldNumber, features, compatibilityLevel, dataFormat, stub);
		}

		internal static IRepeatedSerializer<T> GetSerializer<T>(MemberInfo original)
		{
			MemberInfo underlyingProvider = RuntimeTypeModel.GetUnderlyingProvider(original, typeof(T));
			MemberInfo memberInfo = underlyingProvider;
			object obj;
			if (!(memberInfo is FieldInfo fieldInfo))
			{
				if (!(memberInfo is MethodInfo methodInfo) || !methodInfo.IsStatic)
				{
					goto IL_0057;
				}
				obj = methodInfo.Invoke(null, null);
			}
			else
			{
				if (!fieldInfo.IsStatic)
				{
					goto IL_0057;
				}
				obj = fieldInfo.GetValue(null);
			}
			goto IL_005a;
			IL_0057:
			obj = null;
			goto IL_005a;
			IL_005a:
			object obj2 = obj;
			if (obj2 is IRepeatedSerializer<T> result)
			{
				return result;
			}
			ThrowHelper.ThrowInvalidOperationException("No suitable repeated serializer resolved for " + typeof(T).NormalizeName());
			return null;
		}
	}
	internal sealed class RepeatedDecorator<TCollection, T> : IRuntimeProtoSerializerNode, ICompiledSerializer
	{
		private readonly int _fieldNumber;

		private readonly SerializerFeatures _features;

		private readonly CompatibilityLevel _compatibilityLevel;

		private readonly DataFormat _dataFormat;

		private readonly RepeatedSerializerStub _stub;

		bool IRuntimeProtoSerializerNode.IsScalar => TypeModel.GetInbuiltSerializer<T>(_compatibilityLevel, _dataFormat)?.Features.IsScalar() ?? false;

		private RepeatedSerializer<TCollection, T> Serializer => (RepeatedSerializer<TCollection, T>)_stub.Serializer;

		public Type ExpectedType => typeof(TCollection);

		public bool RequiresOldValue => true;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public RepeatedDecorator(int fieldNumber, SerializerFeatures features, CompatibilityLevel compatibilityLevel, DataFormat dataFormat, RepeatedSerializerStub stub)
		{
			_stub = stub;
			_fieldNumber = fieldNumber;
			_features = features;
			_compatibilityLevel = ValueMember.GetEffectiveCompatibilityLevel(compatibilityLevel, dataFormat);
			_dataFormat = dataFormat;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return Serializer.ReadRepeated(ref state, _features, (TCollection)value, TypeModel.GetInbuiltSerializer<T>(_compatibilityLevel, _dataFormat));
		}

		public void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			_ = Serializer;
			MethodInfo method = typeof(RepeatedSerializer<TCollection, T>).GetMethod("ReadRepeated");
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			_stub.EmitProvider(ctx);
			ctx.LoadState();
			ctx.LoadValue((int)_features);
			ctx.LoadValue(local);
			ctx.LoadSelfAsService<ISerializer<T>, T>(_compatibilityLevel, _dataFormat);
			ctx.EmitCall(method);
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			Serializer.WriteRepeated(ref state, _fieldNumber, _features, (TCollection)value, TypeModel.GetInbuiltSerializer<T>(_compatibilityLevel, _dataFormat));
		}

		public void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			MethodInfo method = typeof(RepeatedSerializer<TCollection, T>).GetMethod("WriteRepeated");
			using Local local = ctx.GetLocalWithValue(ExpectedType, valueFrom);
			_stub.EmitProvider(ctx);
			ctx.LoadState();
			ctx.LoadValue(_fieldNumber);
			ctx.LoadValue((int)_features);
			ctx.LoadValue(local);
			ctx.LoadSelfAsService<ISerializer<T>, T>(_compatibilityLevel, _dataFormat);
			ctx.EmitCall(method);
		}
	}
	internal sealed class SByteSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly SByteSerializer Instance = new SByteSerializer();

		private static readonly Type expectedType = typeof(sbyte);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private SByteSerializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadSByte();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteSByte((sbyte)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteSByte", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadSByte", ExpectedType);
		}
	}
	internal sealed class SingleSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly SingleSerializer Instance = new SingleSerializer();

		private static readonly Type expectedType = typeof(float);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private SingleSerializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadSingle();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteSingle((float)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteSingle", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadSingle", ExpectedType);
		}
	}
	internal sealed class StringSerializer : IRuntimeProtoSerializerNode, IDirectWriteNode
	{
		internal static readonly StringSerializer Instance = new StringSerializer();

		private static readonly Type expectedType = typeof(string);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private StringSerializer()
		{
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteString((string)value);
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadString();
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(string), valueFrom);
			ctx.LoadState();
			ctx.LoadValue(local);
			ctx.LoadNullRef();
			ctx.EmitCall(typeof(ProtoWriter.State).GetMethod("WriteString", BindingFlags.Instance | BindingFlags.Public, null, new Type[2]
			{
				typeof(string),
				typeof(StringMap)
			}, null));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.LoadState();
			ctx.LoadNullRef();
			ctx.EmitCall(typeof(ProtoReader.State).GetMethod("ReadString", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(StringMap) }, null));
		}

		bool IDirectWriteNode.CanEmitDirectWrite(WireType wireType)
		{
			return wireType == WireType.String;
		}

		void IDirectWriteNode.EmitDirectWrite(int fieldNumber, WireType wireType, CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(string), valueFrom);
			ctx.LoadState();
			ctx.LoadValue(fieldNumber);
			ctx.LoadValue(local);
			ctx.LoadNullRef();
			ctx.EmitCall(typeof(ProtoWriter.State).GetMethod("WriteString", BindingFlags.Instance | BindingFlags.Public, null, new Type[3]
			{
				typeof(int),
				typeof(string),
				typeof(StringMap)
			}, null));
		}
	}
	internal sealed class SubTypeSerializer<TParent, TChild> : SubItemSerializer, IDirectWriteNode where TParent : class where TChild : class, TParent
	{
		private static readonly Dictionary<int, MethodInfo> s_WriteSubType = (from method in typeof(ProtoWriter.State).GetMethods(BindingFlags.Instance | BindingFlags.Public)
			where method.Name == "WriteSubType" && method.IsGenericMethod
			select new
			{
				ArgCount = method.GetParameters().Length,
				Method = method
			}).ToDictionary(x => x.ArgCount, x => x.Method);

		public override bool IsSubType => true;

		public override Type ExpectedType => typeof(TChild);

		public override Type BaseType => typeof(TParent);

		public override void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteSubType((TChild)value);
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			SubTypeState<TParent> subTypeState = (SubTypeState<TParent>)value;
			subTypeState.ReadSubType<TChild>(ref state);
			return subTypeState;
		}

		public override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(TChild), valueFrom);
			ctx.LoadState();
			ctx.LoadValue(local);
			ctx.LoadSelfAsService<ISubTypeSerializer<TChild>, TChild>(CompatibilityLevel.NotSpecified, DataFormat.Default);
			ctx.EmitCall(s_WriteSubType[2].MakeGenericMethod(typeof(TChild)));
		}

		bool IDirectWriteNode.CanEmitDirectWrite(WireType wireType)
		{
			return wireType == WireType.String;
		}

		void IDirectWriteNode.EmitDirectWrite(int fieldNumber, WireType wireType, CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(TChild), valueFrom);
			ctx.LoadState();
			ctx.LoadValue(fieldNumber);
			ctx.LoadValue(local);
			ctx.LoadSelfAsService<ISubTypeSerializer<TChild>, TChild>(CompatibilityLevel.NotSpecified, DataFormat.Default);
			ctx.EmitCall(s_WriteSubType[3].MakeGenericMethod(typeof(TChild)));
		}

		public override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			Type typeFromHandle = typeof(SubTypeState<TParent>);
			ctx.LoadAddress(valueFrom, typeFromHandle);
			ctx.LoadState();
			ctx.LoadSelfAsService<ISubTypeSerializer<TChild>, TChild>(CompatibilityLevel.NotSpecified, DataFormat.Default);
			ctx.EmitCall(typeFromHandle.GetMethod("ReadSubType").MakeGenericMethod(typeof(TChild)));
		}
	}
	internal class SubValueSerializer<T> : SubItemSerializer, IDirectWriteNode
	{
		private ISerializer<T> _customSerializer;

		public override bool IsSubType => false;

		public override Type ExpectedType => typeof(T);

		private ISerializer<T> CustomSerializer
		{
			get
			{
				object obj;
				if ((object)base.MetaType.SerializerType != null)
				{
					obj = _customSerializer;
					if (obj == null)
					{
						return CreateExternal();
					}
				}
				else
				{
					obj = null;
				}
				return (ISerializer<T>)obj;
			}
		}

		private ISerializer<T> CreateExternal()
		{
			return _customSerializer = (ISerializer<T>)SerializerCache.GetInstance(base.MetaType.SerializerType, typeof(T));
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			SerializerFeatures category = GetCategory();
			switch (category)
			{
			case SerializerFeatures.CategoryMessage:
			case SerializerFeatures.CategoryMessageWrappedAtRoot:
				state.WriteMessage(SerializerFeatures.CategoryRepeated, TypeHelper<T>.FromObject(value), CustomSerializer);
				break;
			case SerializerFeatures.CategoryScalar:
				CustomSerializer.Write(ref state, TypeHelper<T>.FromObject(value));
				break;
			default:
				category.ThrowInvalidCategory();
				break;
			}
		}

		private SerializerFeatures GetCategory()
		{
			return CustomSerializer?.Features.GetCategory() ?? SerializerFeatures.CategoryMessage;
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			SerializerFeatures category = GetCategory();
			switch (category)
			{
			case SerializerFeatures.CategoryMessage:
			case SerializerFeatures.CategoryMessageWrappedAtRoot:
				return state.ReadMessage(SerializerFeatures.CategoryRepeated, TypeHelper<T>.FromObject(value), CustomSerializer);
			case SerializerFeatures.CategoryScalar:
				return CustomSerializer.Read(ref state, TypeHelper<T>.FromObject(value));
			default:
				category.ThrowInvalidCategory();
				return null;
			}
		}

		protected override WireType GetDefaultWireType(ref DataFormat dataFormat)
		{
			ISerializer<T> customSerializer = CustomSerializer;
			if (customSerializer != null)
			{
				SerializerFeatures features = customSerializer.Features;
				if (features.GetCategory() == SerializerFeatures.CategoryScalar)
				{
					return features.GetWireType();
				}
			}
			return base.GetDefaultWireType(ref dataFormat);
		}

		public override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			SerializerFeatures category = GetCategory();
			switch (GetCategory())
			{
			case SerializerFeatures.CategoryMessage:
			case SerializerFeatures.CategoryMessageWrappedAtRoot:
				SubItemSerializer.EmitWriteMessage<T>(null, WireType.String, ctx, valueFrom, null, applyRecursionCheck: true, base.MetaType.SerializerType);
				break;
			case SerializerFeatures.CategoryScalar:
			{
				using Local local = ctx.GetLocalWithValue(typeof(T), valueFrom);
				SubItemSerializer.EmitLoadCustomSerializer(ctx, base.MetaType.SerializerType, typeof(T));
				ctx.LoadState();
				ctx.LoadValue(local);
				ctx.EmitCall(typeof(ISerializer<T>).GetMethod("Write", BindingFlags.Instance | BindingFlags.Public));
				break;
			}
			default:
				category.ThrowInvalidCategory();
				break;
			}
		}

		public override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(typeof(T), valueFrom);
			SerializerFeatures category = GetCategory();
			switch (category)
			{
			case SerializerFeatures.CategoryMessage:
			case SerializerFeatures.CategoryMessageWrappedAtRoot:
				SubItemSerializer.EmitReadMessage<T>(ctx, local, null, base.MetaType.SerializerType);
				break;
			case SerializerFeatures.CategoryScalar:
				SubItemSerializer.EmitLoadCustomSerializer(ctx, base.MetaType.SerializerType, typeof(T));
				ctx.LoadState();
				ctx.LoadValue(local);
				ctx.EmitCall(typeof(ISerializer<T>).GetMethod("Read", BindingFlags.Instance | BindingFlags.Public));
				break;
			default:
				category.ThrowInvalidCategory();
				break;
			}
		}

		bool IDirectWriteNode.CanEmitDirectWrite(WireType wireType)
		{
			SerializerFeatures category = GetCategory();
			if (category == SerializerFeatures.CategoryMessage || category == SerializerFeatures.CategoryMessageWrappedAtRoot)
			{
				return wireType switch
				{
					WireType.String => true, 
					WireType.StartGroup => true, 
					_ => false, 
				};
			}
			return false;
		}

		void IDirectWriteNode.EmitDirectWrite(int fieldNumber, WireType wireType, CompilerContext ctx, Local valueFrom)
		{
			SubItemSerializer.EmitWriteMessage<T>(fieldNumber, wireType, ctx, valueFrom, null, applyRecursionCheck: true, base.MetaType.SerializerType);
		}
	}
	internal abstract class SubItemSerializer : IProtoTypeSerializer, IRuntimeProtoSerializerNode
	{
		private static readonly Dictionary<int, MethodInfo> s_WriteMessage = (from method in typeof(ProtoWriter.State).GetMethods(BindingFlags.Instance | BindingFlags.Public)
			where method.Name == "WriteMessage" && method.IsGenericMethodDefinition && method.GetGenericArguments().Length == 1
			select new
			{
				ArgCount = method.GetParameters().Length,
				Method = method
			}).ToDictionary(x => x.ArgCount, x => x.Method);

		private static readonly Dictionary<int, MethodInfo> s_WriteGroup = (from method in typeof(ProtoWriter.State).GetMethods(BindingFlags.Instance | BindingFlags.Public)
			where method.Name == "WriteGroup" && method.IsGenericMethodDefinition && method.GetGenericArguments().Length == 1
			select new
			{
				ArgCount = method.GetParameters().Length,
				Method = method
			}).ToDictionary(x => x.ArgCount, x => x.Method);

		private static readonly MethodInfo s_ReadMessage = (from method in typeof(ProtoReader.State).GetMethods(BindingFlags.Instance | BindingFlags.Public)
			where method.Name == "ReadMessage" && method.IsGenericMethodDefinition && method.GetGenericArguments().Length == 1 && method.GetParameters().Length == 3
			select method).Single();

		bool IRuntimeProtoSerializerNode.IsScalar => false;

		SerializerFeatures IProtoTypeSerializer.Features
		{
			get
			{
				ThrowHelper.ThrowNotImplementedException("Features");
				return SerializerFeatures.CategoryRepeated;
			}
		}

		public abstract bool IsSubType { get; }

		public abstract Type ExpectedType { get; }

		public virtual Type BaseType => ExpectedType;

		bool IProtoTypeSerializer.HasInheritance => false;

		bool IProtoTypeSerializer.ShouldEmitCreateInstance
		{
			get
			{
				if (Proxy.Serializer is IProtoTypeSerializer protoTypeSerializer)
				{
					return protoTypeSerializer.ShouldEmitCreateInstance;
				}
				return false;
			}
		}

		bool IRuntimeProtoSerializerNode.RequiresOldValue => true;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		protected ISerializerProxy Proxy => MetaType;

		protected MetaType MetaType { get; private set; }

		public abstract void Write(ref ProtoWriter.State state, object value);

		public abstract object Read(ref ProtoReader.State state, object value);

		public abstract void EmitWrite(CompilerContext ctx, Local valueFrom);

		public abstract void EmitRead(CompilerContext ctx, Local valueFrom);

		void IProtoTypeSerializer.EmitReadRoot(CompilerContext ctx, Local valueFrom)
		{
			((IRuntimeProtoSerializerNode)this).EmitRead(ctx, valueFrom);
		}

		void IProtoTypeSerializer.EmitWriteRoot(CompilerContext ctx, Local valueFrom)
		{
			((IRuntimeProtoSerializerNode)this).EmitWrite(ctx, valueFrom);
		}

		bool IProtoTypeSerializer.HasCallbacks(TypeModel.CallbackType callbackType)
		{
			if (Proxy.Serializer is IProtoTypeSerializer protoTypeSerializer)
			{
				return protoTypeSerializer.HasCallbacks(callbackType);
			}
			return false;
		}

		bool IProtoTypeSerializer.CanCreateInstance()
		{
			if (Proxy.Serializer is IProtoTypeSerializer protoTypeSerializer)
			{
				return protoTypeSerializer.CanCreateInstance();
			}
			return false;
		}

		void IProtoTypeSerializer.EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
			((IProtoTypeSerializer)Proxy.Serializer).EmitCallback(ctx, valueFrom, callbackType);
		}

		void IProtoTypeSerializer.EmitCreateInstance(CompilerContext ctx, bool callNoteObject)
		{
			((IProtoTypeSerializer)Proxy.Serializer).EmitCreateInstance(ctx, callNoteObject);
		}

		void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
			((IProtoTypeSerializer)Proxy.Serializer).Callback(value, callbackType, context);
		}

		object IProtoTypeSerializer.CreateInstance(ISerializationContext source)
		{
			return ((IProtoTypeSerializer)Proxy.Serializer).CreateInstance(source);
		}

		protected static void EmitLoadCustomSerializer(CompilerContext ctx, Type serializerType, Type forType)
		{
			MemberInfo underlyingProvider = RuntimeTypeModel.GetUnderlyingProvider(serializerType, forType);
			RuntimeTypeModel.EmitProvider(underlyingProvider, ctx.IL);
		}

		public static void EmitWriteMessage<T>(int? fieldNumber, WireType wireType, CompilerContext ctx, Local value = null, FieldInfo serializer = null, bool applyRecursionCheck = true, Type serializerType = null)
		{
			using Local local = ctx.GetLocalWithValue(typeof(T), value);
			ctx.LoadState();
			if (fieldNumber.HasValue)
			{
				ctx.LoadValue(fieldNumber.Value);
			}
			ctx.LoadValue((!applyRecursionCheck) ? 1024 : 0);
			ctx.LoadValue(local);
			LoadSerializer<T>(ctx, serializer, serializerType);
			Dictionary<int, MethodInfo> dictionary = ((wireType != WireType.StartGroup) ? s_WriteMessage : s_WriteGroup);
			Dictionary<int, MethodInfo> dictionary2 = dictionary;
			ctx.EmitCall(dictionary2[fieldNumber.HasValue ? 4 : 3].MakeGenericMethod(typeof(T)));
		}

		private static void LoadSerializer<T>(CompilerContext ctx, FieldInfo serializer, Type serializerType)
		{
			if ((object)serializerType != null && (ctx.NonPublic || RuntimeTypeModel.IsFullyPublic(serializerType)))
			{
				EmitLoadCustomSerializer(ctx, serializerType, typeof(T));
			}
			else if ((object)serializer != null)
			{
				ctx.LoadValue(serializer, checkAccessibility: false);
			}
			else
			{
				ctx.LoadSelfAsService<ISerializer<T>, T>(CompatibilityLevel.NotSpecified, DataFormat.Default);
			}
		}

		public static void EmitReadMessage<T>(CompilerContext ctx, Local value = null, FieldInfo serializer = null, Type serializerType = null)
		{
			ctx.LoadState();
			ctx.LoadValue(0);
			if (value == null)
			{
				if (TypeHelper<T>.IsReferenceType)
				{
					ctx.LoadNullRef();
				}
				else
				{
					using Local local = new Local(ctx, typeof(T));
					ctx.InitLocal(typeof(T), local);
					ctx.LoadValue(local);
				}
			}
			else
			{
				ctx.LoadValue(value);
			}
			LoadSerializer<T>(ctx, serializer, serializerType);
			ctx.EmitCall(s_ReadMessage.MakeGenericMethod(typeof(T)));
		}

		internal static IRuntimeProtoSerializerNode Create(Type type, MetaType metaType, ref DataFormat dataFormat, out WireType defaultWireType)
		{
			SubItemSerializer subItemSerializer = (SubItemSerializer)Activator.CreateInstance(typeof(SubValueSerializer<>).MakeGenericType(type), nonPublic: true);
			subItemSerializer.MetaType = metaType ?? throw new ArgumentNullException("metaType");
			defaultWireType = subItemSerializer.GetDefaultWireType(ref dataFormat);
			return subItemSerializer;
		}

		protected virtual WireType GetDefaultWireType(ref DataFormat dataFormat)
		{
			if (dataFormat != DataFormat.Group)
			{
				return WireType.String;
			}
			return WireType.StartGroup;
		}

		internal static IRuntimeProtoSerializerNode Create(Type actualType, MetaType metaType, Type parentType)
		{
			SubItemSerializer subItemSerializer = (SubItemSerializer)Activator.CreateInstance(typeof(SubTypeSerializer<, >).MakeGenericType(parentType, actualType), nonPublic: true);
			subItemSerializer.MetaType = metaType ?? throw new ArgumentNullException("metaType");
			return subItemSerializer;
		}
	}
	internal sealed class SurrogateSerializer<T> : IProtoTypeSerializer, IRuntimeProtoSerializerNode, ISerializer<T>
	{
		private readonly Type declaredType;

		private readonly MethodInfo toTail;

		private readonly MethodInfo fromTail;

		private readonly IRuntimeProtoSerializerNode rootTail;

		private readonly SerializerFeatures features;

		public SerializerFeatures Features => features;

		bool IProtoTypeSerializer.IsSubType => false;

		bool IProtoTypeSerializer.ShouldEmitCreateInstance => false;

		bool IRuntimeProtoSerializerNode.IsScalar => features.IsScalar();

		public bool ReturnsValue => rootTail.ReturnsValue;

		public bool RequiresOldValue => rootTail.RequiresOldValue;

		public Type ExpectedType => typeof(T);

		Type IProtoTypeSerializer.BaseType => ExpectedType;

		bool IProtoTypeSerializer.HasInheritance => false;

		bool IProtoTypeSerializer.HasCallbacks(TypeModel.CallbackType callbackType)
		{
			return false;
		}

		void IProtoTypeSerializer.EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
		}

		void IProtoTypeSerializer.EmitCreateInstance(CompilerContext ctx, bool callNoteObject)
		{
			throw new NotSupportedException();
		}

		bool IProtoTypeSerializer.CanCreateInstance()
		{
			return false;
		}

		object IProtoTypeSerializer.CreateInstance(ISerializationContext source)
		{
			throw new NotSupportedException();
		}

		void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
		}

		T ISerializer<T>.Read(ref ProtoReader.State state, T value)
		{
			return (T)Read(ref state, value);
		}

		void ISerializer<T>.Write(ref ProtoWriter.State state, T value)
		{
			Write(ref state, value);
		}

		public SurrogateSerializer(Type declaredType, MethodInfo toTail, MethodInfo fromTail, IRuntimeProtoSerializerNode rootTail, SerializerFeatures features)
		{
			this.declaredType = declaredType;
			this.rootTail = rootTail;
			this.toTail = toTail ?? GetConversion(toTail: true);
			this.fromTail = fromTail ?? GetConversion(toTail: false);
			this.features = features;
		}

		private static bool HasCast(Type type, Type from, Type to, out MethodInfo op)
		{
			MethodInfo[] methods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			Type type2 = null;
			foreach (MethodInfo methodInfo in methods)
			{
				if (methodInfo.ReturnType != to)
				{
					continue;
				}
				ParameterInfo[] parameters = methodInfo.GetParameters();
				if (parameters.Length != 1 || !(parameters[0].ParameterType == from))
				{
					continue;
				}
				if ((object)type2 == null)
				{
					type2 = typeof(ProtoConverterAttribute);
					if ((object)type2 == null)
					{
						break;
					}
				}
				if (methodInfo.IsDefined(type2, inherit: true))
				{
					op = methodInfo;
					return true;
				}
			}
			foreach (MethodInfo methodInfo2 in methods)
			{
				if ((!(methodInfo2.Name != "op_Implicit") || !(methodInfo2.Name != "op_Explicit")) && !(methodInfo2.ReturnType != to))
				{
					ParameterInfo[] parameters = methodInfo2.GetParameters();
					if (parameters.Length == 1 && parameters[0].ParameterType == from)
					{
						op = methodInfo2;
						return true;
					}
				}
			}
			op = null;
			return false;
		}

		public MethodInfo GetConversion(bool toTail)
		{
			Type to = (toTail ? declaredType : ExpectedType);
			Type from = (toTail ? ExpectedType : declaredType);
			if (HasCast(declaredType, from, to, out var op) || HasCast(ExpectedType, from, to, out op))
			{
				return op;
			}
			throw new InvalidOperationException("No suitable conversion operator found for surrogate: " + ExpectedType.FullName + " / " + declaredType.FullName);
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			rootTail.Write(ref state, toTail.Invoke(null, new object[1] { value }));
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			object[] array = new object[1];
			if (rootTail.RequiresOldValue)
			{
				array[0] = value;
				value = toTail.Invoke(null, array);
			}
			else
			{
				value = null;
			}
			array[0] = rootTail.Read(ref state, value);
			return fromTail.Invoke(null, array);
		}

		void IProtoTypeSerializer.EmitReadRoot(CompilerContext ctx, Local valueFrom)
		{
			((IRuntimeProtoSerializerNode)this).EmitRead(ctx, valueFrom);
		}

		void IProtoTypeSerializer.EmitWriteRoot(CompilerContext ctx, Local valueFrom)
		{
			((IRuntimeProtoSerializerNode)this).EmitWrite(ctx, valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local valueFrom)
		{
			using Local local = (rootTail.RequiresOldValue ? new Local(ctx, declaredType) : null);
			if (rootTail.RequiresOldValue)
			{
				ctx.LoadValue(valueFrom);
				ctx.EmitCall(toTail);
				ctx.StoreValue(local);
			}
			rootTail.EmitRead(ctx, local);
			ctx.LoadValue(local);
			ctx.EmitCall(fromTail);
			ctx.StoreValue(valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.LoadValue(valueFrom);
			ctx.EmitCall(toTail);
			rootTail.EmitWrite(ctx, null);
		}
	}
	internal sealed class SystemTypeSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly SystemTypeSerializer Instance = new SystemTypeSerializer();

		private static readonly Type expectedType = typeof(Type);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private SystemTypeSerializer()
		{
		}

		void IRuntimeProtoSerializerNode.Write(ref ProtoWriter.State state, object value)
		{
			state.WriteType((Type)value);
		}

		object IRuntimeProtoSerializerNode.Read(ref ProtoReader.State state, object value)
		{
			return state.ReadType();
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteType", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadType", ExpectedType);
		}
	}
	internal sealed class TagDecorator : ProtoDecoratorBase, IProtoTypeSerializer, IRuntimeProtoSerializerNode
	{
		private readonly bool strict;

		private readonly int fieldNumber;

		private readonly WireType wireType;

		SerializerFeatures IProtoTypeSerializer.Features => wireType.AsFeatures();

		bool IProtoTypeSerializer.IsSubType
		{
			get
			{
				if (Tail is IProtoTypeSerializer protoTypeSerializer)
				{
					return protoTypeSerializer.IsSubType;
				}
				return false;
			}
		}

		bool IProtoTypeSerializer.ShouldEmitCreateInstance
		{
			get
			{
				if (Tail is IProtoTypeSerializer protoTypeSerializer)
				{
					return protoTypeSerializer.ShouldEmitCreateInstance;
				}
				return false;
			}
		}

		public override Type ExpectedType => Tail.ExpectedType;

		Type IProtoTypeSerializer.BaseType => ExpectedType;

		public override bool RequiresOldValue => Tail.RequiresOldValue;

		public override bool ReturnsValue => Tail.ReturnsValue;

		private bool NeedsHint => (wireType & (WireType)(-8)) != 0;

		bool IProtoTypeSerializer.HasInheritance => false;

		public bool HasCallbacks(TypeModel.CallbackType callbackType)
		{
			if (Tail is IProtoTypeSerializer protoTypeSerializer)
			{
				return protoTypeSerializer.HasCallbacks(callbackType);
			}
			return false;
		}

		public bool CanCreateInstance()
		{
			if (Tail is IProtoTypeSerializer protoTypeSerializer)
			{
				return protoTypeSerializer.CanCreateInstance();
			}
			return false;
		}

		public object CreateInstance(ISerializationContext source)
		{
			return ((IProtoTypeSerializer)Tail).CreateInstance(source);
		}

		public void Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
			(Tail as IProtoTypeSerializer)?.Callback(value, callbackType, context);
		}

		public void EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
			((IProtoTypeSerializer)Tail).EmitCallback(ctx, valueFrom, callbackType);
		}

		public void EmitCreateInstance(CompilerContext ctx, bool callNoteObject)
		{
			((IProtoTypeSerializer)Tail).EmitCreateInstance(ctx, callNoteObject);
		}

		public TagDecorator(int fieldNumber, WireType wireType, bool strict, IRuntimeProtoSerializerNode tail)
			: base(tail)
		{
			this.fieldNumber = fieldNumber;
			this.wireType = wireType;
			this.strict = strict;
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			if (strict)
			{
				state.Assert(wireType);
			}
			else if (NeedsHint)
			{
				state.Hint(wireType);
			}
			return Tail.Read(ref state, value);
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			if (Tail is IDirectRuntimeWriteNode directRuntimeWriteNode && directRuntimeWriteNode.CanDirectWrite(wireType))
			{
				directRuntimeWriteNode.DirectWrite(fieldNumber, wireType, ref state, value);
				return;
			}
			state.WriteFieldHeader(fieldNumber, wireType);
			Tail.Write(ref state, value);
		}

		void IProtoTypeSerializer.EmitReadRoot(CompilerContext ctx, Local valueFrom)
		{
			EmitRead(ctx, valueFrom);
		}

		void IProtoTypeSerializer.EmitWriteRoot(CompilerContext ctx, Local valueFrom)
		{
			EmitWrite(ctx, valueFrom);
		}

		protected override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			if (Tail is IDirectWriteNode directWriteNode && directWriteNode.CanEmitDirectWrite(wireType))
			{
				directWriteNode.EmitDirectWrite(fieldNumber, wireType, ctx, valueFrom);
				return;
			}
			ctx.LoadState();
			ctx.LoadValue(fieldNumber);
			ctx.LoadValue((int)wireType);
			ctx.EmitCall(typeof(ProtoWriter.State).GetMethod("WriteFieldHeader"));
			Tail.EmitWrite(ctx, valueFrom);
		}

		public bool CanEmitDirectWrite()
		{
			if (Tail is IDirectWriteNode directWriteNode)
			{
				return directWriteNode.CanEmitDirectWrite(wireType);
			}
			return false;
		}

		public void EmitDirectWrite(CompilerContext ctx, Local valueFrom)
		{
			((IDirectWriteNode)Tail).EmitDirectWrite(fieldNumber, wireType, ctx, valueFrom);
		}

		protected override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			if (strict || NeedsHint)
			{
				ctx.LoadState();
				ctx.LoadValue((int)wireType);
				string name = (strict ? "Assert" : "Hint");
				ctx.EmitCall(typeof(ProtoReader.State).GetMethod(name, new Type[1] { typeof(WireType) }));
			}
			Tail.EmitRead(ctx, valueFrom);
		}
	}
	internal sealed class TimeSpanSerializer : IRuntimeProtoSerializerNode
	{
		private static TimeSpanSerializer s_Legacy;

		private static TimeSpanSerializer s_Duration;

		private static readonly Type expectedType = typeof(TimeSpan);

		private readonly bool _useDuration;

		bool IRuntimeProtoSerializerNode.IsScalar => false;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		public static TimeSpanSerializer Create(CompatibilityLevel compatibilityLevel)
		{
			object obj;
			if (compatibilityLevel < CompatibilityLevel.Level240)
			{
				obj = s_Legacy;
				if (obj == null)
				{
					return s_Legacy = new TimeSpanSerializer(useDuration: false);
				}
			}
			else
			{
				obj = s_Duration ?? (s_Duration = new TimeSpanSerializer(useDuration: true));
			}
			return (TimeSpanSerializer)obj;
		}

		private TimeSpanSerializer(bool useDuration)
		{
			_useDuration = useDuration;
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			if (_useDuration)
			{
				return BclHelpers.ReadDuration(ref state);
			}
			return BclHelpers.ReadTimeSpan(ref state);
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			if (_useDuration)
			{
				BclHelpers.WriteDuration(ref state, (TimeSpan)value);
			}
			else
			{
				BclHelpers.WriteTimeSpan(ref state, (TimeSpan)value);
			}
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite(_useDuration ? "WriteDuration" : "WriteTimeSpan", valueFrom, typeof(BclHelpers));
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			if (_useDuration)
			{
				ctx.LoadValue(entity);
			}
			ctx.EmitStateBasedRead(typeof(BclHelpers), _useDuration ? "ReadDuration" : "ReadTimeSpan", ExpectedType);
		}
	}
	internal sealed class TupleSerializer<T> : IProtoTypeSerializer, IRuntimeProtoSerializerNode, ISerializer<T>
	{
		private readonly MemberInfo[] members;

		private readonly ConstructorInfo ctor;

		private readonly IRuntimeProtoSerializerNode[] tails;

		bool IRuntimeProtoSerializerNode.IsScalar => false;

		public SerializerFeatures Features { get; private set; } = SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;


		bool IProtoTypeSerializer.IsSubType => false;

		public Type ExpectedType => typeof(T);

		Type IProtoTypeSerializer.BaseType => typeof(T);

		public bool RequiresOldValue => true;

		public bool ReturnsValue => false;

		bool IProtoTypeSerializer.ShouldEmitCreateInstance => false;

		bool IProtoTypeSerializer.HasInheritance => false;

		public TupleSerializer(RuntimeTypeModel model, ConstructorInfo ctor, MemberInfo[] members, SerializerFeatures features, CompatibilityLevel compatibilityLevel)
		{
			this.ctor = ctor ?? throw new ArgumentNullException("ctor");
			this.members = members ?? throw new ArgumentNullException("members");
			tails = new IRuntimeProtoSerializerNode[members.Length];
			Features = features;
			ParameterInfo[] parameters = ctor.GetParameters();
			for (int i = 0; i < members.Length; i++)
			{
				Type parameterType = parameters[i].ParameterType;
				RepeatedSerializerStub repeatedSerializerStub = model.TryGetRepeatedProvider(parameterType);
				Type type = repeatedSerializerStub?.ItemType ?? parameterType;
				bool asReference = false;
				int num = model.FindOrAddAuto(type, demand: false, addWithContractOnly: true, addEvenIfAutoDisabled: false, compatibilityLevel);
				if (num >= 0)
				{
					asReference = model[type].AsReferenceDefault;
				}
				WireType defaultWireType;
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode = ValueMember.TryGetCoreSerializer(model, DataFormat.Default, compatibilityLevel, type, out defaultWireType, asReference, dynamicType: false, overwriteList: false, allowComplexTypes: true);
				if (runtimeProtoSerializerNode == null)
				{
					ThrowHelper.NoSerializerDefined(type);
				}
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode2;
				if (repeatedSerializerStub == null)
				{
					runtimeProtoSerializerNode2 = new TagDecorator(i + 1, defaultWireType, strict: false, runtimeProtoSerializerNode);
				}
				else if (repeatedSerializerStub.IsMap)
				{
					runtimeProtoSerializerNode2 = ValueMember.CreateMap(repeatedSerializerStub, model, DataFormat.Default, compatibilityLevel, DataFormat.Default, DataFormat.Default, asReference, dynamicType: false, isMap: true, overwriteList: false, i + 1, null);
				}
				else
				{
					SerializerFeatures features2 = defaultWireType.AsFeatures() | SerializerFeatures.OptionPackedDisabled;
					runtimeProtoSerializerNode2 = RepeatedDecorator.Create(repeatedSerializerStub, i + 1, features2, compatibilityLevel, DataFormat.Default);
				}
				tails[i] = runtimeProtoSerializerNode2;
			}
		}

		public bool HasCallbacks(TypeModel.CallbackType callbackType)
		{
			return false;
		}

		public void EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
		}

		void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
		}

		object IProtoTypeSerializer.CreateInstance(ISerializationContext source)
		{
			throw new NotSupportedException();
		}

		private object GetValue(object obj, int index)
		{
			if (members[index] is PropertyInfo propertyInfo)
			{
				if (obj == null)
				{
					if (!propertyInfo.PropertyType.IsValueType)
					{
						return null;
					}
					return Activator.CreateInstance(propertyInfo.PropertyType, nonPublic: true);
				}
				return propertyInfo.GetValue(obj, null);
			}
			if (members[index] is FieldInfo fieldInfo)
			{
				if (obj == null)
				{
					if (!fieldInfo.FieldType.IsValueType)
					{
						return null;
					}
					return Activator.CreateInstance(fieldInfo.FieldType, nonPublic: true);
				}
				return fieldInfo.GetValue(obj);
			}
			throw new InvalidOperationException();
		}

		T ISerializer<T>.Read(ref ProtoReader.State state, T value)
		{
			return (T)Read(ref state, value);
		}

		void ISerializer<T>.Write(ref ProtoWriter.State state, T value)
		{
			Write(ref state, value);
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			object[] array = new object[members.Length];
			bool flag = false;
			if (value == null)
			{
				flag = true;
			}
			for (int i = 0; i < array.Length; i++)
			{
				array[i] = GetValue(value, i);
			}
			int num;
			while ((num = state.ReadFieldHeader()) > 0)
			{
				flag = true;
				if (num <= tails.Length)
				{
					IRuntimeProtoSerializerNode runtimeProtoSerializerNode = tails[num - 1];
					array[num - 1] = tails[num - 1].Read(ref state, runtimeProtoSerializerNode.RequiresOldValue ? array[num - 1] : null);
				}
				else
				{
					state.SkipField();
				}
			}
			if (!flag)
			{
				return value;
			}
			return ctor.Invoke(array);
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			for (int i = 0; i < tails.Length; i++)
			{
				object value2 = GetValue(value, i);
				if (value2 != null)
				{
					tails[i].Write(ref state, value2);
				}
			}
		}

		bool IProtoTypeSerializer.CanCreateInstance()
		{
			return false;
		}

		private Type GetMemberType(int index)
		{
			Type memberType = Helpers.GetMemberType(members[index]);
			if ((object)memberType == null)
			{
				throw new InvalidOperationException();
			}
			return memberType;
		}

		public void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			using Local local = ctx.GetLocalWithValue(ctor.DeclaringType, valueFrom);
			for (int i = 0; i < tails.Length; i++)
			{
				Type memberType = GetMemberType(i);
				ctx.LoadAddress(local, ExpectedType);
				if (members[i] is FieldInfo field)
				{
					ctx.LoadValue(field);
				}
				else if (members[i] is PropertyInfo property)
				{
					ctx.LoadValue(property);
				}
				ctx.WriteNullCheckedTail(memberType, tails[i], null);
			}
		}

		void IProtoTypeSerializer.EmitCreateInstance(CompilerContext ctx, bool callNoteObject)
		{
			throw new NotSupportedException();
		}

		void IProtoTypeSerializer.EmitReadRoot(CompilerContext ctx, Local valueFrom)
		{
			EmitRead(ctx, valueFrom);
		}

		void IProtoTypeSerializer.EmitWriteRoot(CompilerContext ctx, Local valueFrom)
		{
			EmitWrite(ctx, valueFrom);
		}

		public void EmitRead(CompilerContext ctx, Local incoming)
		{
			using Local local = ctx.GetLocalWithValue(ExpectedType, incoming);
			Local[] array = new Local[members.Length];
			try
			{
				for (int i = 0; i < array.Length; i++)
				{
					Type memberType = GetMemberType(i);
					bool flag = true;
					array[i] = new Local(ctx, memberType);
					if (ExpectedType.IsValueType)
					{
						continue;
					}
					if (memberType.IsValueType)
					{
						switch (Helpers.GetTypeCode(memberType))
						{
						case ProtoTypeCode.Boolean:
						case ProtoTypeCode.SByte:
						case ProtoTypeCode.Byte:
						case ProtoTypeCode.Int16:
						case ProtoTypeCode.UInt16:
						case ProtoTypeCode.Int32:
						case ProtoTypeCode.UInt32:
							ctx.LoadValue(0);
							break;
						case ProtoTypeCode.Int64:
						case ProtoTypeCode.UInt64:
							ctx.LoadValue(0L);
							break;
						case ProtoTypeCode.Single:
							ctx.LoadValue(0f);
							break;
						case ProtoTypeCode.Double:
							ctx.LoadValue(0.0);
							break;
						case ProtoTypeCode.Decimal:
							ctx.LoadValue(0m);
							break;
						case ProtoTypeCode.Guid:
							ctx.LoadValue(Guid.Empty);
							break;
						default:
							ctx.LoadAddress(array[i], memberType);
							ctx.EmitCtor(memberType);
							flag = false;
							break;
						}
					}
					else
					{
						ctx.LoadNullRef();
					}
					if (flag)
					{
						ctx.StoreValue(array[i]);
					}
				}
				CodeLabel label = (ExpectedType.IsValueType ? default(CodeLabel) : ctx.DefineLabel());
				if (!ExpectedType.IsValueType)
				{
					ctx.LoadAddress(local, ExpectedType);
					ctx.BranchIfFalse(label, @short: false);
				}
				for (int j = 0; j < members.Length; j++)
				{
					ctx.LoadAddress(local, ExpectedType);
					if (members[j] is FieldInfo field)
					{
						ctx.LoadValue(field);
					}
					else if (members[j] is PropertyInfo property)
					{
						ctx.LoadValue(property);
					}
					ctx.StoreValue(array[j]);
				}
				if (!ExpectedType.IsValueType)
				{
					ctx.MarkLabel(label);
				}
				using (Local local2 = new Local(ctx, typeof(int)))
				{
					CodeLabel label2 = ctx.DefineLabel();
					CodeLabel label3 = ctx.DefineLabel();
					CodeLabel label4 = ctx.DefineLabel();
					ctx.Branch(label2, @short: false);
					CodeLabel[] array2 = new CodeLabel[members.Length];
					for (int k = 0; k < members.Length; k++)
					{
						array2[k] = ctx.DefineLabel();
					}
					ctx.MarkLabel(label3);
					ctx.LoadValue(local2);
					ctx.LoadValue(1);
					ctx.Subtract();
					ctx.Switch(array2);
					ctx.Branch(label4, @short: false);
					for (int l = 0; l < array2.Length; l++)
					{
						ctx.MarkLabel(array2[l]);
						IRuntimeProtoSerializerNode runtimeProtoSerializerNode = tails[l];
						Local valueFrom = (runtimeProtoSerializerNode.RequiresOldValue ? array[l] : null);
						ctx.ReadNullCheckedTail(array[l].Type, runtimeProtoSerializerNode, valueFrom);
						if (runtimeProtoSerializerNode.ReturnsValue)
						{
							if (array[l].Type.IsValueType)
							{
								ctx.StoreValue(array[l]);
							}
							else
							{
								CodeLabel label5 = ctx.DefineLabel();
								CodeLabel label6 = ctx.DefineLabel();
								ctx.CopyValue();
								ctx.BranchIfTrue(label5, @short: true);
								ctx.DiscardValue();
								ctx.Branch(label6, @short: true);
								ctx.MarkLabel(label5);
								ctx.StoreValue(array[l]);
								ctx.MarkLabel(label6);
							}
						}
						ctx.Branch(label2, @short: false);
					}
					ctx.MarkLabel(label4);
					ctx.LoadState();
					ctx.EmitCall(typeof(ProtoReader.State).GetMethod("SkipField", Type.EmptyTypes));
					ctx.MarkLabel(label2);
					ctx.EmitStateBasedRead("ReadFieldHeader", typeof(int));
					ctx.CopyValue();
					ctx.StoreValue(local2);
					ctx.LoadValue(0);
					ctx.BranchIfGreater(label3, @short: false);
				}
				for (int m = 0; m < array.Length; m++)
				{
					ctx.LoadValue(array[m]);
				}
				ctx.EmitCtor(ctor);
				ctx.StoreValue(local);
			}
			finally
			{
				for (int n = 0; n < array.Length; n++)
				{
					if (array[n] != null)
					{
						array[n].Dispose();
					}
				}
			}
		}
	}
	internal abstract class TypeSerializer
	{
		public static IProtoTypeSerializer Create(Type forType, int[] fieldNumbers, IRuntimeProtoSerializerNode[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, bool assertKnownType, CallbackSet callbacks, Type constructType, MethodInfo factory, Type rootType, SerializerFeatures features)
		{
			TypeSerializer typeSerializer = (TypeSerializer)(((object)rootType != null) ? Activator.CreateInstance(typeof(InheritanceTypeSerializer<, >).MakeGenericType(rootType, forType), nonPublic: true) : Activator.CreateInstance(typeof(TypeSerializer<>).MakeGenericType(forType), nonPublic: true));
			typeSerializer.Init(fieldNumbers, serializers, baseCtorCallbacks, isRootType, useConstructor, assertKnownType, callbacks, constructType, factory, features);
			return (IProtoTypeSerializer)typeSerializer;
		}

		internal abstract void Init(int[] fieldNumbers, IRuntimeProtoSerializerNode[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, bool assertKnownType, CallbackSet callbacks, Type constructType, MethodInfo factory, SerializerFeatures features);
	}
	internal sealed class InheritanceTypeSerializer<TBase, T> : TypeSerializer<T>, ISubTypeSerializer<T> where TBase : class where T : class, TBase
	{
		public override bool HasInheritance => true;

		internal override Type BaseType => typeof(TBase);

		public override bool IsSubType => true;

		public override void Write(ref ProtoWriter.State state, T value)
		{
			state.WriteBaseType((TBase)value);
		}

		public override T Read(ref ProtoReader.State state, T value)
		{
			return state.ReadBaseType<TBase, T>(value);
		}

		T ISubTypeSerializer<T>.ReadSubType(ref ProtoReader.State state, SubTypeState<T> value)
		{
			value.OnBeforeDeserialize(_subTypeOnBeforeDeserialize);
			DeserializeBody(ref state, ref value, delegate(ref SubTypeState<T> s)
			{
				return s.Value;
			}, delegate(ref SubTypeState<T> s, T v)
			{
				s.Value = v;
			});
			T value2 = value.Value;
			Callback(ref value2, TypeModel.CallbackType.AfterDeserialize, state.Context);
			return value2;
		}

		void ISubTypeSerializer<T>.WriteSubType(ref ProtoWriter.State state, T value)
		{
			SerializeImpl(ref state, value);
		}

		public override void EmitReadRoot(CompilerContext context, Local valueFrom)
		{
			if (context.IsService)
			{
				using (Local local = context.GetLocalWithValue(typeof(T), valueFrom))
				{
					context.LoadSelfAsService<ISubTypeSerializer<TBase>, TBase>(CompatibilityLevel.NotSpecified, DataFormat.Default);
					context.LoadState();
					context.LoadSerializationContext(typeof(ISerializationContext));
					context.LoadValue(local);
					context.EmitCall(typeof(SubTypeState<TBase>).GetMethod("Create", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(typeof(T)));
					context.EmitCall(typeof(ISubTypeSerializer<TBase>).GetMethod("ReadSubType", BindingFlags.Instance | BindingFlags.Public));
					if (typeof(T) != typeof(TBase))
					{
						context.Cast(typeof(T));
					}
					return;
				}
			}
			context.LoadState();
			context.LoadValue(valueFrom);
			context.LoadSelfAsService<ISubTypeSerializer<TBase>, TBase>(CompatibilityLevel.NotSpecified, DataFormat.Default);
			context.EmitCall(typeof(ProtoReader.State).GetMethod("ReadBaseType", BindingFlags.Instance | BindingFlags.Public).MakeGenericMethod(typeof(TBase), typeof(T)));
		}

		public override void EmitWriteRoot(CompilerContext context, Local valueFrom)
		{
			using Local local = context.GetLocalWithValue(typeof(T), valueFrom);
			if (context.IsService)
			{
				context.LoadSelfAsService<ISubTypeSerializer<TBase>, TBase>(CompatibilityLevel.NotSpecified, DataFormat.Default);
				context.LoadState();
				context.LoadValue(local);
				context.EmitCall(typeof(ISubTypeSerializer<TBase>).GetMethod("WriteSubType", BindingFlags.Instance | BindingFlags.Public));
			}
			else
			{
				context.LoadState();
				context.LoadValue(local);
				context.LoadSelfAsService<ISubTypeSerializer<TBase>, TBase>(CompatibilityLevel.NotSpecified, DataFormat.Default);
				context.EmitCall(typeof(ProtoWriter).GetMethod("WriteBaseType", BindingFlags.Instance | BindingFlags.Public).MakeGenericMethod(typeof(TBase)));
			}
		}
	}
	internal class TypeSerializer<T> : TypeSerializer, ISerializer<T>, IFactory<T>, IProtoTypeSerializer, IRuntimeProtoSerializerNode
	{
		private enum StateFlags
		{
			None = 0,
			IsRootType = 1,
			HasConstructor = 2,
			UseConstructor = 4,
			IsExtensible = 8,
			IsTypedExtensible = 0x10,
			AssertKnownType = 0x20
		}

		protected delegate T StateGetter<TState>(ref TState state);

		protected delegate void StateSetter<TState>(ref TState state, T value);

		private Type constructType;

		private IRuntimeProtoSerializerNode[] serializers;

		private int[] fieldNumbers;

		private StateFlags flags;

		private CallbackSet callbacks;

		private MethodInfo[] baseCtorCallbacks;

		private MethodInfo factory;

		protected Action<T, ISerializationContext> _subTypeOnBeforeDeserialize;

		bool IRuntimeProtoSerializerNode.IsScalar => false;

		public virtual bool HasInheritance => false;

		public virtual bool IsSubType => false;

		public Type ExpectedType => typeof(T);

		internal virtual Type BaseType => typeof(T);

		Type IProtoTypeSerializer.BaseType => BaseType;

		public SerializerFeatures Features { get; private set; }

		private bool CanHaveInheritance
		{
			get
			{
				if (ExpectedType.IsClass || ExpectedType.IsInterface)
				{
					return !ExpectedType.IsSealed;
				}
				return false;
			}
		}

		bool IRuntimeProtoSerializerNode.RequiresOldValue => true;

		bool IRuntimeProtoSerializerNode.ReturnsValue => false;

		private bool UseTypedExtensible
		{
			get
			{
				if (GetFlag(StateFlags.IsTypedExtensible))
				{
					if (!HasInheritance)
					{
						return !GetFlag(StateFlags.IsExtensible);
					}
					return true;
				}
				return false;
			}
		}

		bool IProtoTypeSerializer.ShouldEmitCreateInstance
		{
			get
			{
				if ((object)factory == null)
				{
					return !GetFlag(StateFlags.UseConstructor);
				}
				return true;
			}
		}

		public virtual void EmitReadRoot(CompilerContext context, Local valueFrom)
		{
			((IRuntimeProtoSerializerNode)this).EmitRead(context, valueFrom);
		}

		public virtual void EmitWriteRoot(CompilerContext context, Local valueFrom)
		{
			((IRuntimeProtoSerializerNode)this).EmitWrite(context, valueFrom);
		}

		T IFactory<T>.Create(ISerializationContext context)
		{
			return (T)CreateInstance(context);
		}

		public virtual void Write(ref ProtoWriter.State state, T value)
		{
			SerializeImpl(ref state, value);
		}

		public virtual T Read(ref ProtoReader.State state, T value)
		{
			if (value == null)
			{
				value = (T)CreateInstance(state.Context);
			}
			Callback(ref value, TypeModel.CallbackType.BeforeDeserialize, state.Context);
			DeserializeBody(ref state, ref value, delegate(ref T o)
			{
				return o;
			}, delegate(ref T o, T v)
			{
				o = v;
			});
			Callback(ref value, TypeModel.CallbackType.AfterDeserialize, state.Context);
			return value;
		}

		void IRuntimeProtoSerializerNode.Write(ref ProtoWriter.State state, object value)
		{
			Write(ref state, TypeHelper<T>.FromObject(value));
		}

		object IRuntimeProtoSerializerNode.Read(ref ProtoReader.State state, object value)
		{
			return Read(ref state, TypeHelper<T>.FromObject(value));
		}

		public bool HasCallbacks(TypeModel.CallbackType callbackType)
		{
			if (!GetFlag(StateFlags.IsRootType))
			{
				return false;
			}
			if (callbacks != null && (object)callbacks[callbackType] != null)
			{
				return true;
			}
			for (int i = 0; i < serializers.Length; i++)
			{
				if (serializers[i].ExpectedType != ExpectedType && ((IProtoTypeSerializer)serializers[i]).HasCallbacks(callbackType))
				{
					return true;
				}
			}
			return false;
		}

		private void SetFlag(StateFlags flag, bool value)
		{
			if (value)
			{
				flags |= flag;
			}
			else
			{
				flags &= ~flag;
			}
		}

		private bool GetFlag(StateFlags flag)
		{
			return (flags & flag) != 0;
		}

		internal override void Init(int[] fieldNumbers, IRuntimeProtoSerializerNode[] serializers, MethodInfo[] baseCtorCallbacks, bool isRootType, bool useConstructor, bool assertKnownType, CallbackSet callbacks, Type constructType, MethodInfo factory, SerializerFeatures features)
		{
			Array.Sort(fieldNumbers, serializers);
			Features = features;
			bool flag = false;
			Type expectedType = ExpectedType;
			for (int i = 0; i < fieldNumbers.Length; i++)
			{
				if (i != 0 && fieldNumbers[i] == fieldNumbers[i - 1])
				{
					throw new InvalidOperationException("Duplicate field-number detected; " + fieldNumbers[i] + " on: " + expectedType.FullName);
				}
				if (!flag && serializers[i].ExpectedType != expectedType)
				{
					flag = true;
				}
			}
			this.factory = factory;
			if ((object)constructType == null)
			{
				constructType = expectedType;
			}
			else if (!expectedType.IsAssignableFrom(constructType))
			{
				throw new InvalidOperationException(expectedType.FullName + " cannot be assigned from " + constructType.FullName);
			}
			this.constructType = constructType;
			this.serializers = serializers;
			this.fieldNumbers = fieldNumbers;
			this.callbacks = callbacks;
			SetFlag(StateFlags.IsRootType, isRootType);
			SetFlag(StateFlags.UseConstructor, useConstructor);
			SetFlag(StateFlags.AssertKnownType, assertKnownType);
			if (baseCtorCallbacks != null)
			{
				MethodInfo[] array = baseCtorCallbacks;
				foreach (MethodInfo methodInfo in array)
				{
					if (!methodInfo.ReflectedType.IsAssignableFrom(expectedType))
					{
						throw new InvalidOperationException("Trying to assign incompatible callback to " + expectedType.FullName);
					}
				}
				if (baseCtorCallbacks.Length == 0)
				{
					baseCtorCallbacks = null;
				}
			}
			this.baseCtorCallbacks = baseCtorCallbacks;
			if ((object)Nullable.GetUnderlyingType(expectedType) != null)
			{
				throw new ArgumentException("Cannot create a TypeSerializer for nullable types", "forType");
			}
			bool flag2 = TypeSerializerMethodCache.Type_IExtensible.IsAssignableFrom(expectedType);
			bool flag3 = TypeSerializerMethodCache.Type_ITypedIExtensible.IsAssignableFrom(expectedType);
			if (flag2 || flag3)
			{
				if (expectedType.IsValueType || ((!isRootType || flag) && !flag3))
				{
					throw new NotSupportedException("IExtensible is not supported in structs or classes with inheritance without ITypedExtensible");
				}
				SetFlag(StateFlags.IsExtensible, flag2);
				SetFlag(StateFlags.IsTypedExtensible, flag3);
			}
			bool flag4 = !constructType.IsAbstract && (object)Helpers.GetConstructor(constructType, Type.EmptyTypes, nonPublic: true) != null;
			SetFlag(StateFlags.HasConstructor, flag4);
			if (constructType != expectedType && useConstructor && !flag4)
			{
				throw new ArgumentException("The supplied default implementation cannot be created: " + constructType.FullName, "constructType");
			}
			if (HasInheritance && callbacks != null)
			{
				_subTypeOnBeforeDeserialize = delegate(T val, ISerializationContext ctx)
				{
					Callback(ref val, TypeModel.CallbackType.BeforeDeserialize, ctx);
				};
			}
		}

		bool IProtoTypeSerializer.CanCreateInstance()
		{
			return true;
		}

		object IProtoTypeSerializer.CreateInstance(ISerializationContext context)
		{
			return CreateInstance(context);
		}

		void IProtoTypeSerializer.Callback(object value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
			if (GetFlag(StateFlags.IsRootType) && callbacks != null)
			{
				InvokeCallback(callbacks[callbackType], value, context);
			}
		}

		public void Callback(ref T value, TypeModel.CallbackType callbackType, ISerializationContext context)
		{
			if (GetFlag(StateFlags.IsRootType) && callbacks != null)
			{
				object obj = value;
				InvokeCallback(callbacks[callbackType], obj, context);
				value = (T)obj;
			}
		}

		private IRuntimeProtoSerializerNode GetMoreSpecificSerializer(object value)
		{
			if (!CanHaveInheritance)
			{
				return null;
			}
			Type type = value.GetType();
			if (type == ExpectedType)
			{
				return null;
			}
			for (int i = 0; i < serializers.Length; i++)
			{
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode = serializers[i];
				if (runtimeProtoSerializerNode is IProtoTypeSerializer protoTypeSerializer && protoTypeSerializer.IsSubType && runtimeProtoSerializerNode.ExpectedType.IsAssignableFrom(type))
				{
					return runtimeProtoSerializerNode;
				}
			}
			if (type == constructType)
			{
				return null;
			}
			if (GetFlag(StateFlags.AssertKnownType))
			{
				TypeModel.ThrowUnexpectedSubtype(ExpectedType, type);
			}
			return null;
		}

		protected void SerializeImpl(ref ProtoWriter.State state, T value)
		{
			Callback(ref value, TypeModel.CallbackType.BeforeSerialize, state.Context);
			if (CanHaveInheritance)
			{
				GetMoreSpecificSerializer(value)?.Write(ref state, value);
			}
			for (int i = 0; i < serializers.Length; i++)
			{
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode = serializers[i];
				if (!(runtimeProtoSerializerNode is IProtoTypeSerializer protoTypeSerializer) || !protoTypeSerializer.IsSubType)
				{
					runtimeProtoSerializerNode.Write(ref state, value);
				}
			}
			if (UseTypedExtensible)
			{
				state.AppendExtensionData((ITypedExtensible)(object)value, ExpectedType);
			}
			else if (GetFlag(StateFlags.IsExtensible))
			{
				state.AppendExtensionData((IExtensible)(object)value);
			}
			Callback(ref value, TypeModel.CallbackType.AfterSerialize, state.Context);
		}

		protected void DeserializeBody<TState>(ref ProtoReader.State state, ref TState bodyState, StateGetter<TState> getter, StateSetter<TState> setter)
		{
			int num = 0;
			int num2 = 0;
			int num3;
			while ((num3 = state.ReadFieldHeader()) > 0)
			{
				bool flag = false;
				if (num3 < num)
				{
					num = (num2 = 0);
				}
				for (int i = num2; i < fieldNumbers.Length; i++)
				{
					if (fieldNumbers[i] != num3)
					{
						continue;
					}
					IRuntimeProtoSerializerNode runtimeProtoSerializerNode = serializers[i];
					if (runtimeProtoSerializerNode is IProtoTypeSerializer protoTypeSerializer && protoTypeSerializer.IsSubType)
					{
						bodyState = (TState)runtimeProtoSerializerNode.Read(ref state, bodyState);
					}
					else
					{
						T val = getter(ref bodyState);
						object obj = val;
						object obj2 = runtimeProtoSerializerNode.Read(ref state, obj);
						if (runtimeProtoSerializerNode.ReturnsValue)
						{
							setter(ref bodyState, (T)obj2);
						}
						else if (ExpectedType.IsValueType)
						{
							setter(ref bodyState, (T)obj);
						}
					}
					num2 = i;
					num = num3;
					flag = true;
					break;
				}
				if (!flag)
				{
					if (UseTypedExtensible)
					{
						T val2 = getter(ref bodyState);
						state.AppendExtensionData((ITypedExtensible)(object)val2, ExpectedType);
					}
					else if (GetFlag(StateFlags.IsExtensible))
					{
						T val3 = getter(ref bodyState);
						state.AppendExtensionData((IExtensible)(object)val3);
					}
					else
					{
						state.SkipField();
					}
				}
			}
		}

		private object InvokeCallback(MethodInfo method, object obj, ISerializationContext serializationContext)
		{
			object result = null;
			if ((object)method != null)
			{
				ParameterInfo[] parameters = method.GetParameters();
				object[] array;
				bool flag;
				if (parameters.Length == 0)
				{
					array = null;
					flag = true;
				}
				else
				{
					array = new object[parameters.Length];
					flag = true;
					for (int i = 0; i < array.Length; i++)
					{
						Type parameterType = parameters[i].ParameterType;
						object obj2;
						if (parameterType == typeof(ISerializationContext))
						{
							obj2 = serializationContext;
						}
						else if (parameterType == typeof(SerializationContext))
						{
							obj2 = SerializationContext.AsSerializationContext(serializationContext);
						}
						else if (parameterType == typeof(StreamingContext))
						{
							obj2 = SerializationContext.AsStreamingContext(serializationContext);
						}
						else if (parameterType == typeof(Type))
						{
							obj2 = constructType;
						}
						else
						{
							obj2 = null;
							flag = false;
						}
						array[i] = obj2;
					}
				}
				if (!flag)
				{
					throw CallbackSet.CreateInvalidCallbackSignature(method);
				}
				result = method.Invoke(obj, array);
			}
			return result;
		}

		private object CreateInstance(ISerializationContext context)
		{
			if ((object)factory != null)
			{
				return InvokeCallback(factory, null, context);
			}
			if (GetFlag(StateFlags.UseConstructor))
			{
				if (!GetFlag(StateFlags.HasConstructor))
				{
					TypeModel.ThrowCannotCreateInstance(constructType);
				}
				return Activator.CreateInstance(constructType, nonPublic: true);
			}
			return BclHelpers.GetUninitializedObject(constructType);
		}

		private void LoadFromState(CompilerContext ctx, Local value)
		{
			if (HasInheritance)
			{
				Type type = typeof(SubTypeState<>).MakeGenericType(typeof(T));
				PropertyInfo property = type.GetProperty("Value");
				ctx.LoadAddress(value, type);
				ctx.EmitCall(property.GetGetMethod());
			}
			else
			{
				ctx.LoadValue(value);
			}
		}

		private void WriteToState(CompilerContext ctx, Local state, Local value, Type type)
		{
			if (HasInheritance)
			{
				Type type2 = typeof(SubTypeState<>).MakeGenericType(typeof(T));
				PropertyInfo property = type2.GetProperty("Value");
				if (value == null)
				{
					using (Local local = new Local(ctx, type))
					{
						ctx.LoadValue(value);
						ctx.StoreValue(local);
						ctx.LoadAddress(state, type2);
						ctx.LoadValue(local);
						ctx.EmitCall(property.GetSetMethod());
						return;
					}
				}
				ctx.LoadAddress(state, type2);
				ctx.LoadValue(value);
				ctx.EmitCall(property.GetSetMethod());
			}
			else
			{
				ctx.LoadValue(value);
				ctx.StoreValue(state);
			}
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			Type expectedType = ExpectedType;
			using Local local = ctx.GetLocalWithValue(expectedType, valueFrom);
			EmitCallbackIfNeeded(ctx, local, TypeModel.CallbackType.BeforeSerialize);
			CodeLabel label = ctx.DefineLabel();
			if (CanHaveInheritance)
			{
				if (serializers.Any((IRuntimeProtoSerializerNode x) => x is IProtoTypeSerializer protoTypeSerializer3 && protoTypeSerializer3.IsSubType))
				{
					ctx.LoadValue(local);
					ctx.EmitCall(typeof(TypeModel).GetMethod("IsSubType", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(typeof(T)));
					ctx.BranchIfFalse(label, @short: false);
					for (int i = 0; i < serializers.Length; i++)
					{
						IRuntimeProtoSerializerNode runtimeProtoSerializerNode = serializers[i];
						Type expectedType2 = runtimeProtoSerializerNode.ExpectedType;
						if (!(runtimeProtoSerializerNode is IProtoTypeSerializer protoTypeSerializer) || !protoTypeSerializer.IsSubType)
						{
							continue;
						}
						CodeLabel label2 = ctx.DefineLabel();
						ctx.LoadValue(local);
						ctx.TryCast(expectedType2);
						using Local local2 = new Local(ctx, expectedType2);
						ctx.StoreValue(local2);
						ctx.LoadValue(local2);
						ctx.BranchIfFalse(label2, @short: false);
						if (expectedType2.IsValueType)
						{
							ctx.LoadValue(local);
							ctx.CastFromObject(expectedType2);
							runtimeProtoSerializerNode.EmitWrite(ctx, null);
						}
						else
						{
							runtimeProtoSerializerNode.EmitWrite(ctx, local2);
						}
						ctx.Branch(label, @short: false);
						ctx.MarkLabel(label2);
					}
				}
				if (GetFlag(StateFlags.AssertKnownType))
				{
					MethodInfo method = (((object)constructType == null || !(constructType != ExpectedType)) ? TypeSerializerMethodCache.ThrowUnexpectedSubtype[1].MakeGenericMethod(ExpectedType) : TypeSerializerMethodCache.ThrowUnexpectedSubtype[2].MakeGenericMethod(ExpectedType, constructType));
					ctx.LoadValue(local);
					ctx.EmitCall(method);
				}
			}
			ctx.MarkLabel(label);
			for (int j = 0; j < serializers.Length; j++)
			{
				IRuntimeProtoSerializerNode runtimeProtoSerializerNode2 = serializers[j];
				if (!(runtimeProtoSerializerNode2 is IProtoTypeSerializer protoTypeSerializer2) || !protoTypeSerializer2.IsSubType)
				{
					runtimeProtoSerializerNode2.EmitWrite(ctx, local);
				}
			}
			if (UseTypedExtensible)
			{
				using Local local3 = ctx.GetLocalWithValue(typeof(ITypedExtensible), local);
				ctx.LoadState();
				ctx.LoadValue(local3);
				ctx.LoadValue(ExpectedType);
				ctx.EmitCall(TypeSerializerMethodCache.Method_Write_AppendExtensionData_ITypedExtensible);
			}
			else if (GetFlag(StateFlags.IsExtensible))
			{
				using Local local4 = ctx.GetLocalWithValue(typeof(IExtensible), local);
				ctx.LoadState();
				ctx.LoadValue(local4);
				ctx.EmitCall(TypeSerializerMethodCache.Method_Write_AppendExtensionData_IExtensible);
			}
			EmitCallbackIfNeeded(ctx, local, TypeModel.CallbackType.AfterSerialize);
		}

		private static void EmitInvokeCallback(CompilerContext ctx, MethodInfo method, Type constructType, Type type, Local valueFrom)
		{
			if ((object)method == null)
			{
				return;
			}
			if (!method.IsStatic)
			{
				if (type.IsValueType)
				{
					ctx.LoadAddress(valueFrom, type);
				}
				else
				{
					ctx.LoadValue(valueFrom);
				}
			}
			ParameterInfo[] parameters = method.GetParameters();
			bool flag = true;
			for (int i = 0; i < parameters.Length; i++)
			{
				Type parameterType = parameters[i].ParameterType;
				if (parameterType == typeof(ISerializationContext) || parameterType == typeof(StreamingContext) || parameterType == typeof(SerializationContext))
				{
					ctx.LoadSerializationContext(parameterType);
				}
				else if (parameterType == typeof(Type))
				{
					Type type2 = constructType ?? type;
					ctx.LoadValue(type2);
				}
				else
				{
					flag = false;
				}
			}
			if (flag)
			{
				ctx.EmitCall(method);
				if ((object)constructType != null && method.ReturnType == typeof(object))
				{
					ctx.CastFromObject(type);
				}
				return;
			}
			throw CallbackSet.CreateInvalidCallbackSignature(method);
		}

		private void EmitCallbackIfNeeded(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
			if (GetFlag(StateFlags.IsRootType) && ((IProtoTypeSerializer)this).HasCallbacks(callbackType))
			{
				if (HasInheritance && callbackType == TypeModel.CallbackType.BeforeDeserialize)
				{
					ThrowHelper.ThrowInvalidOperationException("Should be using sub-type-state API");
				}
				else if (HasInheritance && callbackType == TypeModel.CallbackType.AfterDeserialize)
				{
					LoadFromState(ctx, valueFrom);
					((IProtoTypeSerializer)this).EmitCallback(ctx, (Local)null, callbackType);
				}
				else
				{
					((IProtoTypeSerializer)this).EmitCallback(ctx, valueFrom, callbackType);
				}
			}
		}

		void IProtoTypeSerializer.EmitCallback(CompilerContext ctx, Local valueFrom, TypeModel.CallbackType callbackType)
		{
			bool flag = false;
			if (CanHaveInheritance)
			{
				for (int i = 0; i < serializers.Length; i++)
				{
					IRuntimeProtoSerializerNode runtimeProtoSerializerNode = serializers[i];
					if (runtimeProtoSerializerNode.ExpectedType != ExpectedType && ((IProtoTypeSerializer)runtimeProtoSerializerNode).HasCallbacks(callbackType))
					{
						flag = true;
						break;
					}
				}
			}
			MethodInfo methodInfo = callbacks?[callbackType];
			if ((object)methodInfo != null || flag)
			{
				EmitInvokeCallback(ctx, methodInfo, null, ExpectedType, valueFrom);
				if (flag && BaseType != ExpectedType)
				{
					throw new NotSupportedException("Currently, serializatation callbacks are limited to the base-type in a hierarchy, but " + ExpectedType.NormalizeName() + " defines callbacks; this may be resolved in later versions; it is recommended to make the serialization callbacks 'virtual' methods on " + BaseType.NormalizeName() + "; or for the best compatibility with other serializers (DataContractSerializer, etc) - make the callbacks non-virtual methods on " + BaseType.NormalizeName() + " that *call* protected virtual methods on " + BaseType.NormalizeName());
				}
			}
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local valueFrom)
		{
			Type type = (HasInheritance ? typeof(SubTypeState<>).MakeGenericType(ExpectedType) : ExpectedType);
			using Local local = ctx.GetLocalWithValue(type, valueFrom);
			using Local local2 = new Local(ctx, typeof(int));
			if (!ExpectedType.IsValueType && !HasInheritance)
			{
				EmitCreateIfNull(ctx, local);
			}
			if (HasCallbacks(TypeModel.CallbackType.BeforeDeserialize))
			{
				if (HasInheritance)
				{
					MethodInfo methodInfo = callbacks?[TypeModel.CallbackType.BeforeDeserialize];
					if ((object)methodInfo != null)
					{
						ctx.LoadAddress(local, type);
						FieldInfo field = ctx.Scope.DefineSubTypeStateCallbackField<T>(methodInfo);
						ctx.LoadValue(field, checkAccessibility: false);
						ctx.EmitCall(type.GetMethod("OnBeforeDeserialize"));
					}
				}
				else
				{
					EmitCallbackIfNeeded(ctx, local, TypeModel.CallbackType.BeforeDeserialize);
				}
			}
			CodeLabel codeLabel = ctx.DefineLabel();
			CodeLabel label = ctx.DefineLabel();
			ctx.Branch(codeLabel, @short: false);
			ctx.MarkLabel(label);
			foreach (BasicList.Group<IRuntimeProtoSerializerNode> contiguousGroup in BasicList.GetContiguousGroups(fieldNumbers, serializers))
			{
				CodeLabel label2 = ctx.DefineLabel();
				int count = contiguousGroup.Items.Count;
				if (count == 1)
				{
					ctx.LoadValue(local2);
					ctx.LoadValue(contiguousGroup.First);
					CodeLabel codeLabel2 = ctx.DefineLabel();
					ctx.BranchIfEqual(codeLabel2, @short: true);
					ctx.Branch(label2, @short: false);
					WriteFieldHandler(ctx, ExpectedType, local, codeLabel2, codeLabel, contiguousGroup.Items[0]);
				}
				else
				{
					ctx.LoadValue(local2);
					ctx.LoadValue(contiguousGroup.First);
					ctx.Subtract();
					CodeLabel[] array = new CodeLabel[count];
					for (int i = 0; i < count; i++)
					{
						array[i] = ctx.DefineLabel();
					}
					ctx.Switch(array);
					ctx.Branch(label2, @short: false);
					for (int j = 0; j < count; j++)
					{
						WriteFieldHandler(ctx, ExpectedType, local, array[j], codeLabel, contiguousGroup.Items[j]);
					}
				}
				ctx.MarkLabel(label2);
			}
			ctx.LoadState();
			if (UseTypedExtensible)
			{
				LoadFromState(ctx, local);
				ctx.LoadValue(ExpectedType);
				ctx.EmitCall(TypeSerializerMethodCache.Method_Read_AppendExtensionData_ITypedExtensible);
			}
			else if (GetFlag(StateFlags.IsExtensible))
			{
				LoadFromState(ctx, local);
				ctx.EmitCall(TypeSerializerMethodCache.Method_Read_AppendExtensionData_IExtensible);
			}
			else
			{
				ctx.EmitCall(typeof(ProtoReader.State).GetMethod("SkipField", Type.EmptyTypes));
			}
			ctx.MarkLabel(codeLabel);
			ctx.EmitStateBasedRead("ReadFieldHeader", typeof(int));
			ctx.CopyValue();
			ctx.StoreValue(local2);
			ctx.LoadValue(0);
			ctx.BranchIfGreater(label, @short: false);
			if (HasCallbacks(TypeModel.CallbackType.AfterDeserialize))
			{
				EmitCallbackIfNeeded(ctx, local, TypeModel.CallbackType.AfterDeserialize);
			}
			if (HasInheritance)
			{
				LoadFromState(ctx, local);
			}
			else if (valueFrom != null && !local.IsSame(valueFrom))
			{
				LoadFromState(ctx, local);
				ctx.StoreValue(valueFrom);
			}
		}

		private void WriteFieldHandler(CompilerContext ctx, Type expected, Local loc, CodeLabel handler, CodeLabel @continue, IRuntimeProtoSerializerNode serializer)
		{
			ctx.MarkLabel(handler);
			bool flag = false;
			if (HasInheritance)
			{
				if (serializer is IProtoTypeSerializer protoTypeSerializer && protoTypeSerializer.IsSubType)
				{
					flag = true;
					serializer.EmitRead(ctx, loc);
				}
				else
				{
					LoadFromState(ctx, loc);
					serializer.EmitRead(ctx, null);
				}
			}
			else
			{
				serializer.EmitRead(ctx, loc);
			}
			if (!flag && serializer.ReturnsValue)
			{
				WriteToState(ctx, loc, null, serializer.ExpectedType);
			}
			ctx.Branch(@continue, @short: false);
		}

		void IProtoTypeSerializer.EmitCreateInstance(CompilerContext ctx, bool callNoteObject)
		{
			if ((object)factory != null)
			{
				EmitInvokeCallback(ctx, factory, constructType, ExpectedType, null);
			}
			else if (!GetFlag(StateFlags.UseConstructor))
			{
				ctx.LoadValue(constructType);
				ctx.EmitCall(typeof(BclHelpers).GetMethod("GetUninitializedObject"));
				ctx.Cast(ExpectedType);
			}
			else if (constructType.IsClass && GetFlag(StateFlags.HasConstructor))
			{
				ctx.EmitCtor(constructType);
			}
			else
			{
				ctx.LoadValue(ExpectedType);
				ctx.LoadNullRef();
				ctx.EmitCall(typeof(TypeModel).GetMethod("ThrowCannotCreateInstance", BindingFlags.Static | BindingFlags.Public));
				ctx.LoadNullRef();
				callNoteObject = false;
			}
			if (callNoteObject || baseCtorCallbacks != null)
			{
				using (Local local = new Local(ctx, ExpectedType))
				{
					ctx.StoreValue(local);
					ctx.LoadValue(local);
				}
			}
		}

		private void EmitCreateIfNull(CompilerContext ctx, Local storage)
		{
			if (!ExpectedType.IsValueType)
			{
				CodeLabel label = ctx.DefineLabel();
				ctx.LoadValue(storage);
				ctx.BranchIfTrue(label, @short: false);
				((IProtoTypeSerializer)this).EmitCreateInstance(ctx, callNoteObject: true);
				ctx.StoreValue(storage);
				ctx.MarkLabel(label);
			}
		}
	}
	internal static class TypeSerializerMethodCache
	{
		internal static readonly Type Type_IExtensible = typeof(IExtensible);

		internal static readonly Type Type_ITypedIExtensible = typeof(ITypedExtensible);

		internal static readonly MethodInfo Method_Write_AppendExtensionData_IExtensible = typeof(ProtoWriter.State).GetMethod("AppendExtensionData", new Type[1] { typeof(IExtensible) });

		internal static readonly MethodInfo Method_Write_AppendExtensionData_ITypedExtensible = typeof(ProtoWriter.State).GetMethod("AppendExtensionData", new Type[2]
		{
			typeof(ITypedExtensible),
			typeof(Type)
		});

		internal static readonly MethodInfo Method_Read_AppendExtensionData_IExtensible = typeof(ProtoReader.State).GetMethod("AppendExtensionData", new Type[1] { typeof(IExtensible) });

		internal static readonly MethodInfo Method_Read_AppendExtensionData_ITypedExtensible = typeof(ProtoReader.State).GetMethod("AppendExtensionData", new Type[2]
		{
			typeof(ITypedExtensible),
			typeof(Type)
		});

		internal static readonly Dictionary<int, MethodInfo> ThrowUnexpectedSubtype = (from method in typeof(TypeModel).GetMethods(BindingFlags.Static | BindingFlags.Public)
			where method.Name == "ThrowUnexpectedSubtype" && method.IsGenericMethodDefinition
			where method.GetParameters().Length == 1
			let args = method.GetGenericArguments()
			select new
			{
				Count = args.Length,
				Method = method
			}).ToDictionary(x => x.Count, x => x.Method);
	}
	internal class UInt16Serializer : IRuntimeProtoSerializerNode
	{
		internal static readonly UInt16Serializer Instance = new UInt16Serializer();

		private static readonly Type expectedType = typeof(ushort);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public virtual Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		protected UInt16Serializer()
		{
		}

		public virtual object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadUInt16();
		}

		public virtual void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteUInt16((ushort)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteUInt16", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadUInt16", typeof(ushort));
		}
	}
	internal sealed class UInt32Serializer : IRuntimeProtoSerializerNode
	{
		internal static readonly UInt32Serializer Instance = new UInt32Serializer();

		private static readonly Type expectedType = typeof(uint);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private UInt32Serializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadUInt32();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteUInt32((uint)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteUInt32", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadUInt32", typeof(uint));
		}
	}
	internal sealed class UInt64Serializer : IRuntimeProtoSerializerNode
	{
		internal static readonly UInt64Serializer Instance = new UInt64Serializer();

		private static readonly Type expectedType = typeof(ulong);

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => expectedType;

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private UInt64Serializer()
		{
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadUInt64();
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteUInt64((ulong)value);
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteUInt64", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadUInt64", ExpectedType);
		}
	}
	internal sealed class UIntPtrSerializer : IRuntimeProtoSerializerNode
	{
		internal static readonly UIntPtrSerializer Instance = new UIntPtrSerializer();

		bool IRuntimeProtoSerializerNode.IsScalar => true;

		public Type ExpectedType => typeof(UIntPtr);

		bool IRuntimeProtoSerializerNode.RequiresOldValue => false;

		bool IRuntimeProtoSerializerNode.ReturnsValue => true;

		private UIntPtrSerializer()
		{
		}

		public void Write(ref ProtoWriter.State state, object value)
		{
			state.WriteUIntPtr((UIntPtr)value);
		}

		public object Read(ref ProtoReader.State state, object value)
		{
			return state.ReadUIntPtr();
		}

		void IRuntimeProtoSerializerNode.EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.EmitStateBasedWrite("WriteUIntPtr", valueFrom);
		}

		void IRuntimeProtoSerializerNode.EmitRead(CompilerContext ctx, Local entity)
		{
			ctx.EmitStateBasedRead("ReadUIntPtr", ExpectedType);
		}
	}
	internal sealed class UriDecorator : ProtoDecoratorBase
	{
		private static readonly Type expectedType = typeof(Uri);

		public override bool IsScalar => true;

		public override Type ExpectedType => expectedType;

		public override bool RequiresOldValue => false;

		public override bool ReturnsValue => true;

		public UriDecorator(IRuntimeProtoSerializerNode tail)
			: base(tail)
		{
		}

		public override void Write(ref ProtoWriter.State state, object value)
		{
			Tail.Write(ref state, ((Uri)value).OriginalString);
		}

		public override object Read(ref ProtoReader.State state, object value)
		{
			string text = (string)Tail.Read(ref state, null);
			if (text.Length != 0)
			{
				return new Uri(text, UriKind.RelativeOrAbsolute);
			}
			return null;
		}

		protected override void EmitWrite(CompilerContext ctx, Local valueFrom)
		{
			ctx.LoadValue(valueFrom);
			ctx.LoadValue(typeof(Uri).GetProperty("OriginalString"));
			Tail.EmitWrite(ctx, null);
		}

		protected override void EmitRead(CompilerContext ctx, Local valueFrom)
		{
			Tail.EmitRead(ctx, valueFrom);
			ctx.CopyValue();
			CodeLabel label = ctx.DefineLabel();
			CodeLabel label2 = ctx.DefineLabel();
			ctx.LoadValue(typeof(string).GetProperty("Length"));
			ctx.BranchIfTrue(label, @short: true);
			ctx.DiscardValue();
			ctx.LoadNullRef();
			ctx.Branch(label2, @short: true);
			ctx.MarkLabel(label);
			ctx.LoadValue(0);
			ctx.EmitCtor(typeof(Uri), typeof(string), typeof(UriKind));
			ctx.MarkLabel(label2);
		}
	}
}
namespace ProtoBuf.Extensions
{
	internal static class StringBuilderExtensions
	{
		public static StringBuilder NewLine(this StringBuilder builder, ref int pos, int indent)
		{
			return builder.Insert(Environment.NewLine, ref pos).Insert(" ", ref pos, indent * 3);
		}

		public static StringBuilder Insert(this StringBuilder builder, string value, ref int pos, Func<bool> condition, int count = 1)
		{
			if (!condition())
			{
				return builder;
			}
			return builder.Insert(value, ref pos, count);
		}

		public static StringBuilder Insert(this StringBuilder builder, string value, ref int pos, int count = 1)
		{
			int length = builder.Length;
			builder.Insert(pos, value, count);
			int num = builder.Length - length;
			pos += num;
			return builder;
		}
	}
}
namespace ProtoBuf.Compiler
{
	[StructLayout(LayoutKind.Auto)]
	[<da4ae7fc-788b-41bf-a5c9-fb56955443e9>IsReadOnly]
	internal struct CodeLabel
	{
		public readonly Label Value;

		public readonly int Index;

		public CodeLabel(Label value, int index)
		{
			Value = value;
			Index = index;
		}
	}
	internal sealed class CompilerContext : IDisposable
	{
		internal enum SignatureType
		{
			WriterScope_Input,
			ReaderScope_Input,
			Context
		}

		internal static class StateBasedReadMethods
		{
			internal static readonly Type ByRefStateType = typeof(ProtoReader.State).MakeByRefType();

			private static readonly Hashtable s_perTypeCache = new Hashtable();

			private static Dictionary<string, MethodInfo> CreateAndAdd(Type parentType)
			{
				Dictionary<string, MethodInfo> dictionary = new Dictionary<string, MethodInfo>(StringComparer.Ordinal);
				MethodInfo[] methods = parentType.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
				foreach (MethodInfo methodInfo in methods)
				{
					if (methodInfo.IsDefined(typeof(ObsoleteAttribute), inherit: true))
					{
						continue;
					}
					ParameterInfo[] parameters = methodInfo.GetParameters();
					if (methodInfo.IsStatic)
					{
						if (parameters.Length != 1 || parameters[0].ParameterType != ByRefStateType)
						{
							continue;
						}
					}
					else if (parameters.Length != 0)
					{
						continue;
					}
					dictionary.Add(methodInfo.Name, methodInfo);
				}
				lock (s_perTypeCache)
				{
					s_perTypeCache[parentType] = dictionary;
					return dictionary;
				}
			}

			internal static bool Find(Type parentType, string methodName, out MethodInfo method)
			{
				Dictionary<string, MethodInfo> dictionary = ((Dictionary<string, MethodInfo>)s_perTypeCache[parentType]) ?? CreateAndAdd(parentType);
				return dictionary.TryGetValue(methodName, out method);
			}
		}

		private sealed class UsingBlock : IDisposable
		{
			private Local local;

			private CompilerContext ctx;

			private CodeLabel label;

			public UsingBlock(CompilerContext ctx, Local local)
			{
				if (local == null)
				{
					throw new ArgumentNullException("local");
				}
				Type type = local.Type;
				if ((!type.IsValueType && !type.IsSealed) || typeof(IDisposable).IsAssignableFrom(type))
				{
					this.local = local;
					this.ctx = ctx ?? throw new ArgumentNullException("ctx");
					label = ctx.BeginTry();
				}
			}

			public void Dispose()
			{
				if (this.local == null || ctx == null)
				{
					return;
				}
				ctx.EndTry(label, @short: false);
				ctx.BeginFinally();
				Type typeFromHandle = typeof(IDisposable);
				MethodInfo method = typeFromHandle.GetMethod("Dispose");
				Type type = this.local.Type;
				if (type.IsValueType)
				{
					ctx.LoadAddress(this.local, type);
					ctx.Constrain(type);
					ctx.EmitCall(method);
				}
				else
				{
					CodeLabel codeLabel = ctx.DefineLabel();
					if (typeFromHandle.IsAssignableFrom(type))
					{
						ctx.LoadValue(this.local);
						ctx.BranchIfFalse(codeLabel, @short: true);
						ctx.LoadAddress(this.local, type);
					}
					else
					{
						using Local local = new Local(ctx, typeFromHandle);
						ctx.LoadValue(this.local);
						ctx.TryCast(typeFromHandle);
						ctx.CopyValue();
						ctx.StoreValue(local);
						ctx.BranchIfFalse(codeLabel, @short: true);
						ctx.LoadAddress(local, typeFromHandle);
					}
					ctx.EmitCall(method);
					ctx.MarkLabel(codeLabel);
				}
				ctx.EndFinally();
				this.local = null;
				ctx = null;
				label = default(CodeLabel);
			}
		}

		private readonly DynamicMethod method;

		private static int next;

		private static readonly MethodInfo s_CreateInstance = typeof(ProtoReader.State).GetMethod("CreateInstance", BindingFlags.Instance | BindingFlags.Public);

		private readonly string _traceName;

		private readonly OpCode _state;

		private readonly byte _inputArg;

		private readonly SignatureType _signature;

		private static readonly MethodInfo s_GetInbuiltSerializer = typeof(TypeModel).GetMethod("GetInbuiltSerializer", BindingFlags.Static | BindingFlags.Public);

		private readonly ILGenerator il;

		private readonly List<LocalBuilder> locals = new List<LocalBuilder>();

		private int nextLabel;

		private List<Assembly> knownTrustedAssemblies;

		private List<Assembly> knownUntrustedAssemblies;

		public TypeModel Model { get; }

		internal bool NonPublic { get; }

		public Local InputValue { get; }

		public bool IsStatic { get; }

		internal CompilerContextScope Scope { get; }

		public bool IsService
		{
			get
			{
				if (Scope.IsFullEmit)
				{
					return !IsStatic;
				}
				return false;
			}
		}

		internal ILGenerator IL => il;

		internal CodeLabel DefineLabel()
		{
			CodeLabel result = new CodeLabel(il.DefineLabel(), nextLabel++);
			return result;
		}

		[Conditional("DEBUG_COMPILE")]
		private void TraceCompile(string value)
		{
		}

		internal void MarkLabel(CodeLabel label)
		{
			il.MarkLabel(label.Value);
		}

		public static ProtoSerializer<TActual> BuildSerializer<TActual>(CompilerContextScope scope, IRuntimeProtoSerializerNode head, TypeModel model)
		{
			Type expectedType = head.ExpectedType;
			try
			{
				using CompilerContext compilerContext = new CompilerContext(scope, expectedType, SignatureType.WriterScope_Input, isStatic: true, model, typeof(TActual), null);
				compilerContext.WriteNullCheckedTail(expectedType, head, compilerContext.InputValue);
				compilerContext.Emit(OpCodes.Ret);
				return (ProtoSerializer<TActual>)compilerContext.method.CreateDelegate(typeof(ProtoSerializer<TActual>));
			}
			catch (Exception innerException)
			{
				string text = expectedType.FullName;
				if (string.IsNullOrEmpty(text))
				{
					text = expectedType.Name;
				}
				throw new InvalidOperationException("It was not possible to prepare a serializer for: " + text, innerException);
			}
		}

		public static ProtoSubTypeDeserializer<T> BuildSubTypeDeserializer<T>(CompilerContextScope scope, IRuntimeProtoSerializerNode head, TypeModel model) where T : class
		{
			using CompilerContext compilerContext = new CompilerContext(scope, head.ExpectedType, SignatureType.ReaderScope_Input, isStatic: true, model, typeof(SubTypeState<T>), typeof(T));
			head.EmitRead(compilerContext, compilerContext.InputValue);
			compilerContext.Return();
			return (ProtoSubTypeDeserializer<T>)compilerContext.method.CreateDelegate(typeof(ProtoSubTypeDeserializer<T>));
		}

		public static ProtoDeserializer<T> BuildDeserializer<T>(CompilerContextScope scope, IRuntimeProtoSerializerNode head, TypeModel model, bool isScalar = false)
		{
			using CompilerContext compilerContext = new CompilerContext(scope, head.ExpectedType, SignatureType.ReaderScope_Input, isStatic: true, model, typeof(T), typeof(T));
			head.EmitRead(compilerContext, compilerContext.InputValue);
			if (!isScalar)
			{
				compilerContext.LoadValue(compilerContext.InputValue);
			}
			compilerContext.Return();
			return (ProtoDeserializer<T>)compilerContext.method.CreateDelegate(typeof(ProtoDeserializer<T>));
		}

		public static Func<ISerializationContext, T> BuildFactory<T>(CompilerContextScope scope, IRuntimeProtoSerializerNode head, TypeModel model)
		{
			if (head is IProtoTypeSerializer protoTypeSerializer && protoTypeSerializer.ShouldEmitCreateInstance)
			{
				using (CompilerContext compilerContext = new CompilerContext(scope, head.ExpectedType, SignatureType.Context, isStatic: true, model, typeof(ISerializationContext), typeof(T)))
				{
					protoTypeSerializer.EmitCreateInstance(compilerContext, callNoteObject: false);
					compilerContext.Return();
					return (Func<ISerializationContext, T>)compilerContext.method.CreateDelegate(typeof(Func<ISerializationContext, T>));
				}
			}
			return null;
		}

		internal void CreateInstance<T>()
		{
			LoadState();
			LoadNullRef();
			EmitCall(s_CreateInstance.MakeGenericMethod(typeof(T)));
		}

		internal void Return()
		{
			Emit(OpCodes.Ret);
		}

		private static bool IsObject(Type type)
		{
			return type == typeof(object);
		}

		internal void CastToObject(Type type)
		{
			if (!IsObject(type))
			{
				if (type.IsValueType)
				{
					il.Emit(OpCodes.Box, type);
				}
				else
				{
					il.Emit(OpCodes.Castclass, typeof(object));
				}
			}
		}

		internal void CastFromObject(Type type)
		{
			if (!IsObject(type))
			{
				if (type.IsValueType)
				{
					il.Emit(OpCodes.Unbox_Any, type);
				}
				else
				{
					il.Emit(OpCodes.Castclass, type);
				}
			}
		}

		internal CompilerContext(CompilerContext parent, ILGenerator il, bool isStatic, SignatureType signature, Type inputType, string traceName)
			: this(parent.Scope, il, isStatic, signature, parent.Model, inputType, traceName)
		{
		}

		internal void ThrowException(Type exceptionType)
		{
			il.ThrowException(exceptionType);
		}

		internal CompilerContext(CompilerContextScope scope, ILGenerator il, bool isStatic, SignatureType signature, TypeModel model, Type inputType, string traceName)
		{
			Scope = scope;
			this.il = il ?? throw new ArgumentNullException("il");
			Model = model ?? throw new ArgumentNullException("model");
			if ((object)inputType != null)
			{
				InputValue = new Local(null, inputType);
			}
			_traceName = traceName;
			IsStatic = isStatic;
			_signature = signature;
			GetOpCodes(signature, isStatic, out _state, out _inputArg);
		}

		public override string ToString()
		{
			return _traceName;
		}

		private static void GetOpCodes(SignatureType signature, bool isStatic, out OpCode state, out byte inputArg)
		{
			if ((uint)signature <= 1u)
			{
				state = (isStatic ? OpCodes.Ldarg_0 : OpCodes.Ldarg_1);
				inputArg = (byte)(isStatic ? 1u : 2u);
			}
			else
			{
				state = default(OpCode);
				inputArg = (byte)((!isStatic) ? 1u : 0u);
			}
		}

		private CompilerContext(CompilerContextScope scope, Type associatedType, SignatureType signature, bool isStatic, TypeModel model, Type inputType, Type returnType)
		{
			Scope = scope;
			Model = model ?? throw new ArgumentNullException("model");
			NonPublic = true;
			_signature = signature;
			GetOpCodes(signature, isStatic, out _state, out _inputArg);
			Type[] parameterTypes = signature switch
			{
				SignatureType.ReaderScope_Input => new Type[2]
				{
					StateBasedReadMethods.ByRefStateType,
					inputType
				}, 
				SignatureType.WriterScope_Input => new Type[2]
				{
					WriterUtil.ByRefStateType,
					inputType
				}, 
				_ => new Type[1] { inputType }, 
			};
			method = new DynamicMethod("proto_" + Interlocked.Increment(ref next).ToString(CultureInfo.InvariantCulture), returnType ?? typeof(void), parameterTypes, associatedType.IsInterface ? typeof(object) : associatedType, skipVisibility: true);
			il = method.GetILGenerator();
			if ((object)inputType != null)
			{
				InputValue = new Local(null, inputType);
			}
			_traceName = method.Name;
			IsStatic = isStatic;
		}

		public void LoadSelfAsService<TService, T>(CompatibilityLevel compatibilityLevel, DataFormat dataFormat) where TService : class
		{
			ISerializer<T> inbuiltSerializer = TypeModel.GetInbuiltSerializer<T>(compatibilityLevel, dataFormat);
			if (IsStatic || inbuiltSerializer != null)
			{
				if (inbuiltSerializer != null && typeof(TService) == typeof(ISerializer<T>) && !(inbuiltSerializer is PrimaryTypeProvider))
				{
					LoadValue((int)compatibilityLevel);
					LoadValue((int)dataFormat);
					EmitCall(s_GetInbuiltSerializer.MakeGenericMethod(typeof(T)));
				}
				else
				{
					LoadNullRef();
				}
			}
			else
			{
				Emit(OpCodes.Ldarg_0);
				if (!Scope.IsFullEmit || !Scope.ImplementsServiceFor<T>(compatibilityLevel))
				{
					TryCast(typeof(TService));
				}
			}
		}

		internal void Emit(OpCode opcode)
		{
			il.Emit(opcode);
		}

		public void LoadValue(string value)
		{
			if (value == null)
			{
				LoadNullRef();
			}
			else
			{
				il.Emit(OpCodes.Ldstr, value);
			}
		}

		public void LoadValue(float value)
		{
			il.Emit(OpCodes.Ldc_R4, value);
		}

		public void LoadValue(double value)
		{
			il.Emit(OpCodes.Ldc_R8, value);
		}

		public void LoadValue(ulong value)
		{
			LoadValue((long)value);
		}

		public void LoadValue(long value)
		{
			il.Emit(OpCodes.Ldc_I8, value);
		}

		public void LoadValue(bool value)
		{
			Emit(value ? OpCodes.Ldc_I4_1 : OpCodes.Ldc_I4_0);
		}

		public void LoadValue(int value)
		{
			switch (value)
			{
			case 0:
				Emit(OpCodes.Ldc_I4_0);
				return;
			case 1:
				Emit(OpCodes.Ldc_I4_1);
				return;
			case 2:
				Emit(OpCodes.Ldc_I4_2);
				return;
			case 3:
				Emit(OpCodes.Ldc_I4_3);
				return;
			case 4:
				Emit(OpCodes.Ldc_I4_4);
				return;
			case 5:
				Emit(OpCodes.Ldc_I4_5);
				return;
			case 6:
				Emit(OpCodes.Ldc_I4_6);
				return;
			case 7:
				Emit(OpCodes.Ldc_I4_7);
				return;
			case 8:
				Emit(OpCodes.Ldc_I4_8);
				return;
			case -1:
				Emit(OpCodes.Ldc_I4_M1);
				return;
			}
			if (value >= -128 && value <= 127)
			{
				il.Emit(OpCodes.Ldc_I4_S, (sbyte)value);
			}
			else
			{
				il.Emit(OpCodes.Ldc_I4, value);
			}
		}

		void IDisposable.Dispose()
		{
		}

		internal LocalBuilder GetFromPool(Type type)
		{
			int count = locals.Count;
			for (int i = 0; i < count; i++)
			{
				LocalBuilder localBuilder = locals[i];
				if (localBuilder != null && localBuilder.LocalType == type)
				{
					locals[i] = null;
					return localBuilder;
				}
			}
			return il.DeclareLocal(type);
		}

		internal void ReleaseToPool(LocalBuilder value)
		{
			int count = locals.Count;
			for (int i = 0; i < count; i++)
			{
				if (locals[i] == null)
				{
					locals[i] = value;
					return;
				}
			}
			locals.Add(value);
		}

		public void LoadState()
		{
			Emit(_state);
		}

		public void StoreValue(Local local)
		{
			if (local == InputValue)
			{
				il.Emit(OpCodes.Starg_S, _inputArg);
			}
			else if (local != null)
			{
				switch (local.Value.LocalIndex)
				{
				case 0:
					Emit(OpCodes.Stloc_0);
					break;
				case 1:
					Emit(OpCodes.Stloc_1);
					break;
				case 2:
					Emit(OpCodes.Stloc_2);
					break;
				case 3:
					Emit(OpCodes.Stloc_3);
					break;
				default:
				{
					OpCode opcode = (UseShortForm(local) ? OpCodes.Stloc_S : OpCodes.Stloc);
					il.Emit(opcode, local.Value);
					break;
				}
				}
			}
		}

		public void LoadValue(Local local)
		{
			if (local == null)
			{
				return;
			}
			if (local == InputValue)
			{
				switch (_inputArg)
				{
				case 0:
					Emit(OpCodes.Ldarg_0);
					break;
				case 1:
					Emit(OpCodes.Ldarg_1);
					break;
				case 2:
					Emit(OpCodes.Ldarg_2);
					break;
				case 3:
					Emit(OpCodes.Ldarg_3);
					break;
				default:
					il.Emit(OpCodes.Ldarg_S, _inputArg);
					break;
				}
				return;
			}
			switch (local.Value.LocalIndex)
			{
			case 0:
				Emit(OpCodes.Ldloc_0);
				break;
			case 1:
				Emit(OpCodes.Ldloc_1);
				break;
			case 2:
				Emit(OpCodes.Ldloc_2);
				break;
			case 3:
				Emit(OpCodes.Ldloc_3);
				break;
			default:
			{
				OpCode opcode = (UseShortForm(local) ? OpCodes.Ldloc_S : OpCodes.Ldloc);
				il.Emit(opcode, local.Value);
				break;
			}
			}
		}

		public Local GetLocalWithValue(Type type, Local fromValue)
		{
			if (fromValue != null)
			{
				if (fromValue.Type == type)
				{
					return fromValue.AsCopy();
				}
				LoadValue(fromValue);
				if (!type.IsValueType && ((object)fromValue.Type == null || !type.IsAssignableFrom(fromValue.Type)))
				{
					Cast(type);
				}
			}
			Local local = new Local(this, type);
			StoreValue(local);
			return local;
		}

		internal void EmitStateBasedRead(string methodName, Type expectedType)
		{
			EmitStateBasedRead(typeof(ProtoReader.State), methodName, expectedType);
		}

		internal void EmitStateBasedRead(Type ownerType, string methodName, Type expectedType)
		{
			if (!StateBasedReadMethods.Find(ownerType, methodName, out var methodInfo))
			{
				throw new ArgumentException("No suitable '" + methodName + "' method found on " + ownerType.Name);
			}
			if (methodInfo.ReturnType != expectedType)
			{
				throw new ArgumentException("Method '" + methodName + "' has wrong return type; got " + methodInfo.ReturnType.Name + ", expected " + expectedType.Name);
			}
			LoadState();
			EmitCall(methodInfo);
		}

		internal void EmitStateBasedWrite(string methodName, Local fromValue, Type type = null, Type argType = null)
		{
			if (string.IsNullOrEmpty(methodName))
			{
				throw new ArgumentNullException("methodName");
			}
			if ((object)type == null)
			{
				type = typeof(ProtoWriter.State);
			}
			Type type2;
			MethodInfo methodInfo;
			try
			{
				var anon = (from method in type.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public)
					where method.Name == methodName && !method.IsGenericMethodDefinition && method.ReturnType == typeof(void)
					let args = method.GetParameters()
					where args.Length == ((!method.IsStatic) ? 1 : 2) && (!method.IsStatic || args[0].ParameterType == WriterUtil.ByRefStateType)
					let paramType = args[method.IsStatic ? 1 : 0].ParameterType
					where (object)argType == null || argType == paramType
					select new
					{
						Method = method,
						Type = paramType
					}).Single();
				type2 = anon.Type;
				methodInfo = anon.Method;
			}
			catch (Exception innerException)
			{
				throw new InvalidOperationException("Unable to uniquely resolve " + type.Name + "." + methodName, innerException);
			}
			using Local local = GetLocalWithValue(type2, fromValue);
			LoadState();
			LoadValue(local);
			EmitCall(methodInfo);
		}

		public void EmitCall(MethodInfo method)
		{
			EmitCall(method, null);
		}

		public void EmitCall(MethodInfo method, Type targetType)
		{
			MemberInfo member = method ?? throw new ArgumentNullException("method");
			CheckAccessibility(ref member);
			OpCode opcode;
			if (method.IsStatic || method.DeclaringType.IsValueType)
			{
				opcode = OpCodes.Call;
			}
			else
			{
				opcode = OpCodes.Callvirt;
				if ((object)targetType != null && targetType.IsValueType && !method.DeclaringType.IsValueType)
				{
					Constrain(targetType);
				}
			}
			il.EmitCall(opcode, method, null);
		}

		public void LoadNullRef()
		{
			Emit(OpCodes.Ldnull);
		}

		internal void WriteNullCheckedTail(Type type, IRuntimeProtoSerializerNode tail, Local valueFrom)
		{
			if (tail is TagDecorator tagDecorator && tagDecorator.ExpectedType == type && tagDecorator.CanEmitDirectWrite())
			{
				tagDecorator.EmitDirectWrite(this, valueFrom);
			}
			else if (type.IsValueType)
			{
				Type underlyingType = Nullable.GetUnderlyingType(type);
				if ((object)underlyingType != null)
				{
					using (Local local = GetLocalWithValue(type, valueFrom))
					{
						LoadAddress(local, type);
						LoadValue(type.GetProperty("HasValue"));
						CodeLabel label = DefineLabel();
						BranchIfFalse(label, @short: false);
						LoadAddress(local, type);
						EmitCall(type.GetMethod("GetValueOrDefault", Type.EmptyTypes));
						tail.EmitWrite(this, null);
						MarkLabel(label);
						return;
					}
				}
				tail.EmitWrite(this, valueFrom);
			}
			else
			{
				LoadValue(valueFrom);
				CopyValue();
				CodeLabel label2 = DefineLabel();
				CodeLabel label3 = DefineLabel();
				BranchIfTrue(label2, @short: true);
				DiscardValue();
				Branch(label3, @short: false);
				MarkLabel(label2);
				tail.EmitWrite(this, null);
				MarkLabel(label3);
			}
		}

		internal void ReadNullCheckedTail(Type type, IRuntimeProtoSerializerNode tail, Local valueFrom)
		{
			Type underlyingType;
			if (type.IsValueType && type != tail.ExpectedType && (object)(underlyingType = Nullable.GetUnderlyingType(type)) != null && underlyingType == tail.ExpectedType)
			{
				if (tail.RequiresOldValue)
				{
					using Local local = GetLocalWithValue(type, valueFrom);
					LoadAddress(local, type);
					EmitCall(type.GetMethod("GetValueOrDefault", Type.EmptyTypes));
				}
				tail.EmitRead(this, null);
				if (tail.ReturnsValue)
				{
					EmitCtor(type, underlyingType);
				}
			}
			else
			{
				tail.EmitRead(this, valueFrom);
			}
		}

		public void EmitCtor(Type type)
		{
			EmitCtor(type, Type.EmptyTypes);
		}

		public void EmitCtor(ConstructorInfo ctor)
		{
			if ((object)ctor == null)
			{
				throw new ArgumentNullException("ctor");
			}
			MemberInfo member = ctor;
			CheckAccessibility(ref member);
			il.Emit(OpCodes.Newobj, ctor);
		}

		public void InitLocal(Type type, Local target)
		{
			LoadAddress(target, type, evenIfClass: true);
			il.Emit(OpCodes.Initobj, type);
		}

		public void EmitCtor(Type type, params Type[] parameterTypes)
		{
			if (type.IsValueType && parameterTypes.Length == 0)
			{
				il.Emit(OpCodes.Initobj, type);
				return;
			}
			ConstructorInfo constructor = Helpers.GetConstructor(type, parameterTypes, nonPublic: true);
			if ((object)constructor == null)
			{
				throw new InvalidOperationException("No suitable constructor found for " + type.FullName);
			}
			EmitCtor(constructor);
		}

		private bool InternalsVisible(Assembly assembly)
		{
			if (string.IsNullOrEmpty(Scope.AssemblyName))
			{
				return false;
			}
			if (knownTrustedAssemblies != null && knownTrustedAssemblies.IndexOf(assembly) >= 0)
			{
				return true;
			}
			if (knownUntrustedAssemblies != null && knownUntrustedAssemblies.IndexOf(assembly) >= 0)
			{
				return false;
			}
			bool flag = false;
			Type typeFromHandle = typeof(InternalsVisibleToAttribute);
			if ((object)typeFromHandle == null)
			{
				return false;
			}
			object[] customAttributes = assembly.GetCustomAttributes(typeFromHandle, inherit: false);
			for (int i = 0; i < customAttributes.Length; i++)
			{
				InternalsVisibleToAttribute internalsVisibleToAttribute = (InternalsVisibleToAttribute)customAttributes[i];
				if (internalsVisibleToAttribute.AssemblyName == Scope.AssemblyName || internalsVisibleToAttribute.AssemblyName.StartsWith(Scope.AssemblyName + ",", StringComparison.Ordinal))
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				(knownTrustedAssemblies ?? (knownTrustedAssemblies = new List<Assembly>())).Add(assembly);
			}
			else
			{
				(knownUntrustedAssemblies ?? (knownUntrustedAssemblies = new List<Assembly>())).Add(assembly);
			}
			return flag;
		}

		internal void CheckAccessibility(ref MemberInfo member)
		{
			if ((object)member == null)
			{
				throw new ArgumentNullException("member");
			}
			if (NonPublic)
			{
				return;
			}
			if (member is FieldInfo && (member.Name.StartsWith("<", StringComparison.Ordinal) & member.Name.EndsWith(">k__BackingField", StringComparison.Ordinal)))
			{
				string name = member.Name.Substring(1, member.Name.Length - 17);
				PropertyInfo property = member.DeclaringType.GetProperty(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public);
				if ((object)property != null)
				{
					member = property;
				}
			}
			MemberTypes memberType = member.MemberType;
			bool flag;
			switch (memberType)
			{
			case MemberTypes.TypeInfo:
			{
				Type type = (Type)member;
				flag = type.IsPublic || InternalsVisible(type.Assembly);
				break;
			}
			case MemberTypes.NestedType:
			{
				Type type = (Type)member;
				do
				{
					flag = type.IsNestedPublic || type.IsPublic || (((object)type.DeclaringType == null || type.IsNestedAssembly || type.IsNestedFamORAssem) && InternalsVisible(type.Assembly));
				}
				while (flag && (object)(type = type.DeclaringType) != null);
				break;
			}
			case MemberTypes.Field:
			{
				FieldInfo fieldInfo = (FieldInfo)member;
				flag = fieldInfo.IsPublic || ((fieldInfo.IsAssembly || fieldInfo.IsFamilyOrAssembly) && InternalsVisible(fieldInfo.DeclaringType.Assembly));
				break;
			}
			case MemberTypes.Constructor:
			{
				ConstructorInfo constructorInfo = (ConstructorInfo)member;
				flag = constructorInfo.IsPublic || ((constructorInfo.IsAssembly || constructorInfo.IsFamilyOrAssembly) && InternalsVisible(constructorInfo.DeclaringType.Assembly));
				break;
			}
			case MemberTypes.Method:
			{
				MethodInfo methodInfo = (MethodInfo)member;
				flag = methodInfo.IsPublic || ((methodInfo.IsAssembly || methodInfo.IsFamilyOrAssembly) && InternalsVisible(methodInfo.DeclaringType.Assembly));
				if (!flag && (member is MethodBuilder || member.DeclaringType == typeof(TypeModel)))
				{
					flag = true;
				}
				break;
			}
			case MemberTypes.Property:
				flag = true;
				break;
			default:
				throw new NotSupportedException(memberType.ToString());
			}
			if (!flag)
			{
				MemberInfo memberInfo = member;
				if (!(memberInfo is FieldBuilder) && !(memberInfo is TypeBuilder) && !(memberInfo is PropertyBuilder))
				{
					InvalidOperationException ex = ((memberType != MemberTypes.TypeInfo && memberType != MemberTypes.NestedType) ? new InvalidOperationException("Non-public member cannot be used with full dll compilation: " + member.DeclaringType.NormalizeName() + "." + member.Name) : new InvalidOperationException("Non-public type cannot be used with full dll compilation: " + ((Type)member).NormalizeName()));
					throw ex;
				}
			}
		}

		public void LoadValue(FieldInfo field, bool checkAccessibility = true)
		{
			MemberInfo member = field;
			if (checkAccessibility)
			{
				CheckAccessibility(ref member);
			}
			if (member is PropertyInfo property)
			{
				LoadValue(property);
				return;
			}
			OpCode opcode = (field.IsStatic ? OpCodes.Ldsfld : OpCodes.Ldfld);
			il.Emit(opcode, field);
		}

		public void StoreValue(FieldInfo field)
		{
			MemberInfo member = field;
			CheckAccessibility(ref member);
			if (member is PropertyInfo property)
			{
				StoreValue(property);
				return;
			}
			OpCode opcode = (field.IsStatic ? OpCodes.Stsfld : OpCodes.Stfld);
			il.Emit(opcode, field);
		}

		public void LoadValue(PropertyInfo property)
		{
			MemberInfo member = property;
			CheckAccessibility(ref member);
			EmitCall(Helpers.GetGetMethod(property, nonPublic: true, allowInternal: true));
		}

		public void StoreValue(PropertyInfo property)
		{
			MemberInfo member = property;
			CheckAccessibility(ref member);
			EmitCall(Helpers.GetSetMethod(property, nonPublic: true, allowInternal: true));
		}

		internal static void LoadValue(ILGenerator il, int value)
		{
			switch (value)
			{
			case 0:
				il.Emit(OpCodes.Ldc_I4_0);
				return;
			case 1:
				il.Emit(OpCodes.Ldc_I4_1);
				return;
			case 2:
				il.Emit(OpCodes.Ldc_I4_2);
				return;
			case 3:
				il.Emit(OpCodes.Ldc_I4_3);
				return;
			case 4:
				il.Emit(OpCodes.Ldc_I4_4);
				return;
			case 5:
				il.Emit(OpCodes.Ldc_I4_5);
				return;
			case 6:
				il.Emit(OpCodes.Ldc_I4_6);
				return;
			case 7:
				il.Emit(OpCodes.Ldc_I4_7);
				return;
			case 8:
				il.Emit(OpCodes.Ldc_I4_8);
				return;
			case -1:
				il.Emit(OpCodes.Ldc_I4_M1);
				return;
			}
			if (value >= -128 && value <= 127)
			{
				il.Emit(OpCodes.Ldc_I4_S, (sbyte)value);
			}
			else
			{
				il.Emit(OpCodes.Ldc_I4, value);
			}
		}

		private static bool UseShortForm(Local local)
		{
			return local.Value.LocalIndex < 256;
		}

		internal void LoadAddress(Local local, Type type, bool evenIfClass = false)
		{
			if (evenIfClass || type.IsValueType)
			{
				if (local == null)
				{
					throw new InvalidOperationException("Cannot load the address of the head of the stack");
				}
				if (local == InputValue)
				{
					il.Emit(OpCodes.Ldarga_S, _inputArg);
					return;
				}
				OpCode opcode = (UseShortForm(local) ? OpCodes.Ldloca_S : OpCodes.Ldloca);
				il.Emit(opcode, local.Value);
			}
			else
			{
				LoadValue(local);
			}
		}

		internal void Branch(CodeLabel label, bool @short)
		{
			OpCode opcode = (@short ? OpCodes.Br_S : OpCodes.Br);
			il.Emit(opcode, label.Value);
		}

		internal void BranchIfFalse(CodeLabel label, bool @short)
		{
			OpCode opcode = (@short ? OpCodes.Brfalse_S : OpCodes.Brfalse);
			il.Emit(opcode, label.Value);
		}

		internal void BranchIfTrue(CodeLabel label, bool @short)
		{
			OpCode opcode = (@short ? OpCodes.Brtrue_S : OpCodes.Brtrue);
			il.Emit(opcode, label.Value);
		}

		internal void BranchIfEqual(CodeLabel label, bool @short)
		{
			OpCode opcode = (@short ? OpCodes.Beq_S : OpCodes.Beq);
			il.Emit(opcode, label.Value);
		}

		internal void CopyValue()
		{
			Emit(OpCodes.Dup);
		}

		internal void BranchIfGreater(CodeLabel label, bool @short)
		{
			OpCode opcode = (@short ? OpCodes.Bgt_S : OpCodes.Bgt);
			il.Emit(opcode, label.Value);
		}

		internal void BranchIfLess(CodeLabel label, bool @short)
		{
			OpCode opcode = (@short ? OpCodes.Blt_S : OpCodes.Blt);
			il.Emit(opcode, label.Value);
		}

		internal void DiscardValue()
		{
			Emit(OpCodes.Pop);
		}

		public void Subtract()
		{
			Emit(OpCodes.Sub);
		}

		public void Switch(CodeLabel[] jumpTable)
		{
			if (jumpTable.Length <= 128)
			{
				Label[] array = new Label[jumpTable.Length];
				for (int i = 0; i < array.Length; i++)
				{
					array[i] = jumpTable[i].Value;
				}
				il.Emit(OpCodes.Switch, array);
				return;
			}
			using Local local = GetLocalWithValue(typeof(int), null);
			int num = jumpTable.Length;
			int num2 = 0;
			int num3 = num / 128;
			if (num % 128 != 0)
			{
				num3++;
			}
			Label[] array2 = new Label[num3];
			for (int j = 0; j < num3; j++)
			{
				array2[j] = il.DefineLabel();
			}
			CodeLabel label = DefineLabel();
			LoadValue(local);
			LoadValue(128);
			Emit(OpCodes.Div);
			il.Emit(OpCodes.Switch, array2);
			Branch(label, @short: false);
			Label[] array3 = new Label[128];
			for (int k = 0; k < num3; k++)
			{
				il.MarkLabel(array2[k]);
				int num4 = Math.Min(128, num);
				num -= num4;
				if (array3.Length != num4)
				{
					array3 = new Label[num4];
				}
				int num5 = num2;
				for (int l = 0; l < num4; l++)
				{
					array3[l] = jumpTable[num2++].Value;
				}
				LoadValue(local);
				if (num5 != 0)
				{
					LoadValue(num5);
					Emit(OpCodes.Sub);
				}
				il.Emit(OpCodes.Switch, array3);
				if (num != 0)
				{
					Branch(label, @short: false);
				}
			}
			MarkLabel(label);
		}

		internal void EndFinally()
		{
			il.EndExceptionBlock();
		}

		internal void BeginFinally()
		{
			il.BeginFinallyBlock();
		}

		internal void EndTry(CodeLabel label, bool @short)
		{
			OpCode opcode = (@short ? OpCodes.Leave_S : OpCodes.Leave);
			il.Emit(opcode, label.Value);
		}

		internal CodeLabel BeginTry()
		{
			CodeLabel result = new CodeLabel(il.BeginExceptionBlock(), nextLabel++);
			return result;
		}

		internal void Constrain(Type type)
		{
			il.Emit(OpCodes.Constrained, type);
		}

		internal void TryCast(Type type)
		{
			il.Emit(OpCodes.Isinst, type);
		}

		internal void Cast(Type type)
		{
			il.Emit(OpCodes.Castclass, type);
		}

		public IDisposable Using(Local local)
		{
			return new UsingBlock(this, local);
		}

		internal void Add()
		{
			Emit(OpCodes.Add);
		}

		internal void LoadLength(Local arr, bool zeroIfNull)
		{
			if (zeroIfNull)
			{
				CodeLabel label = DefineLabel();
				CodeLabel label2 = DefineLabel();
				LoadValue(arr);
				CopyValue();
				BranchIfTrue(label, @short: true);
				DiscardValue();
				LoadValue(0);
				Branch(label2, @short: true);
				MarkLabel(label);
				Emit(OpCodes.Ldlen);
				Emit(OpCodes.Conv_I4);
				MarkLabel(label2);
			}
			else
			{
				LoadValue(arr);
				Emit(OpCodes.Ldlen);
				Emit(OpCodes.Conv_I4);
			}
		}

		internal void CreateArray(Type elementType, Local length)
		{
			LoadValue(length);
			il.Emit(OpCodes.Newarr, elementType);
		}

		internal void LoadArrayValue(Local arr, Local i)
		{
			Type type = arr.Type;
			type = type.GetElementType();
			LoadValue(arr);
			LoadValue(i);
			switch (Helpers.GetTypeCode(type))
			{
			case ProtoTypeCode.SByte:
				Emit(OpCodes.Ldelem_I1);
				return;
			case ProtoTypeCode.Int16:
				Emit(OpCodes.Ldelem_I2);
				return;
			case ProtoTypeCode.Int32:
				Emit(OpCodes.Ldelem_I4);
				return;
			case ProtoTypeCode.Int64:
				Emit(OpCodes.Ldelem_I8);
				return;
			case ProtoTypeCode.Byte:
				Emit(OpCodes.Ldelem_U1);
				return;
			case ProtoTypeCode.UInt16:
				Emit(OpCodes.Ldelem_U2);
				return;
			case ProtoTypeCode.UInt32:
				Emit(OpCodes.Ldelem_U4);
				return;
			case ProtoTypeCode.UInt64:
				Emit(OpCodes.Ldelem_I8);
				return;
			case ProtoTypeCode.Single:
				Emit(OpCodes.Ldelem_R4);
				return;
			case ProtoTypeCode.Double:
				Emit(OpCodes.Ldelem_R8);
				return;
			}
			if (type.IsValueType)
			{
				il.Emit(OpCodes.Ldelema, type);
				il.Emit(OpCodes.Ldobj, type);
			}
			else
			{
				Emit(OpCodes.Ldelem_Ref);
			}
		}

		internal static void LoadValue(ILGenerator il, Type type)
		{
			il.Emit(OpCodes.Ldtoken, type);
			il.EmitCall(OpCodes.Call, typeof(Type).GetMethod("GetTypeFromHandle"), null);
		}

		internal void LoadValue(Type type)
		{
			il.Emit(OpCodes.Ldtoken, type);
			EmitCall(typeof(Type).GetMethod("GetTypeFromHandle"));
		}

		internal void ConvertToInt32(ProtoTypeCode typeCode, bool uint32Overflow)
		{
			switch (typeCode)
			{
			case ProtoTypeCode.SByte:
			case ProtoTypeCode.Byte:
			case ProtoTypeCode.Int16:
			case ProtoTypeCode.UInt16:
				Emit(OpCodes.Conv_I4);
				break;
			case ProtoTypeCode.Int64:
				Emit(OpCodes.Conv_Ovf_I4);
				break;
			case ProtoTypeCode.UInt32:
				Emit(uint32Overflow ? OpCodes.Conv_Ovf_I4_Un : OpCodes.Conv_Ovf_I4);
				break;
			case ProtoTypeCode.UInt64:
				Emit(OpCodes.Conv_Ovf_I4_Un);
				break;
			default:
				throw new InvalidOperationException("ConvertToInt32 not implemented for: " + typeCode);
			case ProtoTypeCode.Int32:
				break;
			}
		}

		internal void ConvertFromInt32(ProtoTypeCode typeCode, bool uint32Overflow)
		{
			switch (typeCode)
			{
			case ProtoTypeCode.SByte:
				Emit(OpCodes.Conv_Ovf_I1);
				break;
			case ProtoTypeCode.Byte:
				Emit(OpCodes.Conv_Ovf_U1);
				break;
			case ProtoTypeCode.Int16:
				Emit(OpCodes.Conv_Ovf_I2);
				break;
			case ProtoTypeCode.UInt16:
				Emit(OpCodes.Conv_Ovf_U2);
				break;
			case ProtoTypeCode.UInt32:
				Emit(uint32Overflow ? OpCodes.Conv_Ovf_U4 : OpCodes.Conv_U4);
				break;
			case ProtoTypeCode.Int64:
				Emit(OpCodes.Conv_I8);
				break;
			case ProtoTypeCode.UInt64:
				Emit(OpCodes.Conv_U8);
				break;
			default:
				throw new InvalidOperationException();
			case ProtoTypeCode.Int32:
				break;
			}
		}

		internal void LoadValue(decimal value)
		{
			if (value == 0m)
			{
				LoadValue(typeof(decimal).GetField("Zero"));
				return;
			}
			int[] bits = decimal.GetBits(value);
			LoadValue(bits[0]);
			LoadValue(bits[1]);
			LoadValue(bits[2]);
			LoadValue(bits[3] >>> 31);
			LoadValue((bits[3] >> 16) & 0xFF);
			EmitCtor(typeof(decimal), typeof(int), typeof(int), typeof(int), typeof(bool), typeof(byte));
		}

		internal void LoadValue(Guid value)
		{
			if (value == Guid.Empty)
			{
				LoadValue(typeof(Guid).GetField("Empty"));
				return;
			}
			byte[] array = value.ToByteArray();
			int value2 = array[0] | (array[1] << 8) | (array[2] << 16) | (array[3] << 24);
			LoadValue(value2);
			short value3 = (short)(array[4] | (array[5] << 8));
			LoadValue(value3);
			value3 = (short)(array[6] | (array[7] << 8));
			LoadValue(value3);
			for (value2 = 8; value2 <= 15; value2++)
			{
				LoadValue(array[value2]);
			}
			EmitCtor(typeof(Guid), typeof(int), typeof(short), typeof(short), typeof(byte), typeof(byte), typeof(byte), typeof(byte), typeof(byte), typeof(byte), typeof(byte), typeof(byte));
		}

		internal void LoadSerializationContext(Type asType)
		{
			LoadState();
			switch (_signature)
			{
			case SignatureType.WriterScope_Input:
				LoadValue(typeof(ProtoWriter.State).GetProperty("Context"));
				break;
			case SignatureType.ReaderScope_Input:
				LoadValue(typeof(ProtoReader.State).GetProperty("Context"));
				break;
			case SignatureType.Context:
				LoadValue(InputValue);
				break;
			default:
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Cannot load context for {_signature}");
				break;
			}
			if (!(asType == typeof(ISerializationContext)))
			{
				if (asType == typeof(SerializationContext))
				{
					EmitCall(typeof(SerializationContext).GetMethod("AsSerializationContext"));
				}
				else if (asType == typeof(StreamingContext))
				{
					EmitCall(typeof(SerializationContext).GetMethod("AsStreamingContext"));
				}
				else
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("Unexpected context type: " + asType.NormalizeName());
				}
			}
		}

		internal bool AllowInternal(PropertyInfo property)
		{
			if (!NonPublic)
			{
				return InternalsVisible(property.DeclaringType.Assembly);
			}
			return true;
		}
	}
	internal sealed class CompilerContextScope
	{
		private static class SharedModule
		{
			internal static readonly ModuleBuilder Shared = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName("SharedModule"), AssemblyBuilderAccess.RunAndCollect).DefineDynamicModule("SharedModule");
		}

		private ModuleBuilder _module;

		private readonly RuntimeTypeModel _model;

		private int _localUniqueId;

		private static int s_globalUniqueId;

		internal string AssemblyName { get; }

		public bool IsFullEmit { get; }

		internal static CompilerContextScope CreateInProcess()
		{
			return new CompilerContextScope(null, null, isFullEmit: false, null);
		}

		internal static CompilerContextScope CreateForModule(RuntimeTypeModel model, ModuleBuilder module, bool isFullEmit, string assemblyName)
		{
			return new CompilerContextScope(model, module, isFullEmit, assemblyName);
		}

		private CompilerContextScope(RuntimeTypeModel model, ModuleBuilder module, bool isFullEmit, string assemblyName)
		{
			_model = model;
			_module = module;
			IsFullEmit = isFullEmit;
			AssemblyName = assemblyName;
		}

		private ModuleBuilder GetModule()
		{
			return _module ?? (_module = GetSharedModule());
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static ModuleBuilder GetSharedModule()
		{
			return SharedModule.Shared;
		}

		internal static ILGenerator Implement(TypeBuilder type, Type interfaceType, string name, bool @explicit = true)
		{
			MethodInfo method = interfaceType.GetMethod(name, BindingFlags.Instance | BindingFlags.Public);
			if ((object)method == null)
			{
				throw new ArgumentException("Declaration not found for '" + name + "'", "name");
			}
			ParameterInfo[] parameters = method.GetParameters();
			string text = name;
			MethodAttributes methodAttributes = (method.Attributes & ~MethodAttributes.Abstract) | MethodAttributes.Final;
			if (@explicit)
			{
				text = interfaceType.NormalizeName() + "." + text;
				methodAttributes &= ~MethodAttributes.MemberAccessMask;
				methodAttributes |= MethodAttributes.Private | MethodAttributes.HideBySig;
			}
			MethodBuilder methodBuilder = type.DefineMethod(text, methodAttributes, method.ReturnType, Array.ConvertAll(parameters, (ParameterInfo x) => x.ParameterType));
			for (int i = 0; i < parameters.Length; i++)
			{
				methodBuilder.DefineParameter(i + 1, parameters[i].Attributes, parameters[i].Name);
			}
			type.DefineMethodOverride(methodBuilder, method);
			return methodBuilder.GetILGenerator();
		}

		private int Uniquify()
		{
			if (!IsFullEmit)
			{
				return Interlocked.Increment(ref s_globalUniqueId);
			}
			return Interlocked.Increment(ref _localUniqueId);
		}

		internal FieldInfo DefineSubTypeStateCallbackField<T>(MethodInfo callback)
		{
			if (typeof(T).IsValueType)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Not expected for value-type");
			}
			Type typeFromHandle = typeof(Action<T, ISerializationContext>);
			ModuleBuilder module = GetModule();
			lock (module)
			{
				string text = "<" + callback.Name + ">_helper_" + Uniquify();
				TypeBuilder typeBuilder;
				try
				{
					typeBuilder = module.DefineType(text, TypeAttributes.Abstract | TypeAttributes.Sealed | TypeAttributes.BeforeFieldInit);
				}
				catch (Exception innerException)
				{
					throw new InvalidOperationException("Unable to define type: " + text, innerException);
				}
				string text2 = "s_" + callback.Name;
				FieldAttributes fieldAttributes = FieldAttributes.Assembly | FieldAttributes.Static;
				if (IsFullEmit)
				{
					fieldAttributes |= FieldAttributes.InitOnly;
				}
				FieldBuilder field = typeBuilder.DefineField(text2, typeFromHandle, fieldAttributes);
				if (IsFullEmit)
				{
					MethodBuilder methodBuilder = typeBuilder.DefineMethod(callback.Name, MethodAttributes.Private | MethodAttributes.Static | MethodAttributes.HideBySig | MethodAttributes.SpecialName | MethodAttributes.RTSpecialName, CallingConventions.Standard, typeof(void), new Type[2]
					{
						typeof(T),
						typeof(ISerializationContext)
					});
					methodBuilder.DefineParameter(1, ParameterAttributes.None, "obj");
					methodBuilder.DefineParameter(2, ParameterAttributes.None, "context");
					WriteCall(methodBuilder.GetILGenerator(), callback);
					ConstructorBuilder constructorBuilder = typeBuilder.DefineTypeInitializer();
					ILGenerator iLGenerator = constructorBuilder.GetILGenerator();
					iLGenerator.Emit(OpCodes.Ldnull);
					iLGenerator.Emit(OpCodes.Ldftn, methodBuilder);
					iLGenerator.Emit(OpCodes.Newobj, typeFromHandle.GetConstructors().Single());
					iLGenerator.Emit(OpCodes.Stsfld, field);
					iLGenerator.Emit(OpCodes.Ret);
				}
				Type type = typeBuilder.CreateType();
				FieldInfo field2 = type.GetField(text2, BindingFlags.Static | BindingFlags.NonPublic);
				if (!IsFullEmit)
				{
					DynamicMethod dynamicMethod = new DynamicMethod(callback.Name, typeof(void), new Type[2]
					{
						typeof(T),
						typeof(ISerializationContext)
					}, typeof(T), skipVisibility: true);
					WriteCall(dynamicMethod.GetILGenerator(), callback);
					field2.SetValue(null, dynamicMethod.CreateDelegate(typeFromHandle));
				}
				return field2;
			}
			static void WriteCall(ILGenerator il, MethodInfo callback)
			{
				il.Emit(OpCodes.Ldarg_0);
				ParameterInfo[] parameters = callback.GetParameters();
				foreach (ParameterInfo parameterInfo in parameters)
				{
					Type parameterType = parameterInfo.ParameterType;
					if (parameterType == typeof(ISerializationContext))
					{
						il.Emit(OpCodes.Ldarg_1);
					}
					else if (parameterType == typeof(SerializationContext))
					{
						il.Emit(OpCodes.Ldarg_1);
						il.EmitCall(OpCodes.Call, typeof(SerializationContext).GetMethod("AsSerializationContext"), null);
					}
					else if (parameterType == typeof(StreamingContext))
					{
						il.Emit(OpCodes.Ldarg_1);
						il.EmitCall(OpCodes.Call, typeof(SerializationContext).GetMethod("AsStreamingContext"), null);
					}
					else
					{
						ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException($"Unknown callback parameter: {parameterInfo.Name}, {parameterType}");
					}
				}
				il.EmitCall(OpCodes.Callvirt, callback, null);
				il.Emit(OpCodes.Ret);
			}
		}

		internal bool ImplementsServiceFor<T>(CompatibilityLevel ambient)
		{
			if (_model == null || typeof(T).IsEnum || (object)Nullable.GetUnderlyingType(typeof(T)) != null)
			{
				return false;
			}
			if (!_model.IsKnownType<T>(ambient))
			{
				return false;
			}
			MetaType metaType = _model[typeof(T)];
			if (metaType == null)
			{
				return false;
			}
			if ((object)metaType.SerializerType != null)
			{
				return false;
			}
			if (_model.TryGetRepeatedProvider(metaType.Type) != null)
			{
				return false;
			}
			return true;
		}
	}
	internal delegate void ProtoSerializer<T>(ref ProtoWriter.State state, T value);
	internal delegate T ProtoDeserializer<T>(ref ProtoReader.State state, T value);
	internal delegate T ProtoSubTypeDeserializer<T>(ref ProtoReader.State state, SubTypeState<T> value) where T : class;
	internal sealed class Local : IDisposable
	{
		private LocalBuilder value;

		private readonly Type type;

		private CompilerContext ctx;

		internal LocalBuilder Value => value ?? throw new ObjectDisposedException(GetType().Name);

		public Type Type => type;

		private Local(LocalBuilder value, Type type)
		{
			this.value = value;
			this.type = type;
		}

		internal Local(CompilerContext ctx, Type type)
		{
			this.ctx = ctx;
			if (ctx != null)
			{
				value = ctx.GetFromPool(type);
			}
			this.type = type;
		}

		public Local AsCopy()
		{
			if (ctx == null)
			{
				return this;
			}
			return new Local(value, type);
		}

		public void Dispose()
		{
			if (ctx != null)
			{
				ctx.ReleaseToPool(value);
				value = null;
				ctx = null;
			}
		}

		internal bool IsSame(Local other)
		{
			if (this == other)
			{
				return true;
			}
			object obj = value;
			if (other != null)
			{
				return obj == other.value;
			}
			return false;
		}
	}
	internal static class WriterUtil
	{
		internal static readonly Type ByRefStateType = typeof(ProtoWriter.State).MakeByRefType();
	}
}
namespace Microsoft.CodeAnalysis
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[Microsoft.CodeAnalysis.Embedded]
	[CompilerGenerated]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsByRefLikeAttribute : Attribute
	{
	}
}
[ExcludeFromCodeCoverage]
[GeneratedCode("Nerdbank.GitVersioning.Tasks", "3.5.119.9565")]
internal static class ThisAssembly
{
	internal const string AssemblyConfiguration = "Release";

	internal const string AssemblyFileVersion = "3.2.26.38424";

	internal const string AssemblyInformationalVersion = "3.2.26+9618de9414";

	internal const string AssemblyName = "protobuf-net.Core";

	internal const string AssemblyTitle = "protobuf-net.Core";

	internal const string AssemblyVersion = "3.0.0.0";

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

	internal const string GitCommitId = "9618de94145145228e115e8f134f132522e51f88";

	internal const bool IsPrerelease = false;

	internal const bool IsPublicRelease = true;

	internal const string PublicKey = "002400000480000094000000060200000024000052534131000400000100010009ed9caa457bfc205716c3d4e8b255a63ddf71c9e53b1b5f574ab6ffdba11e80ab4b50be9c46d43b75206280070ddba67bd4c830f93f0317504a76ba6a48243c36d2590695991164592767a7bbc4453b34694e31e20815a096e4483605139a32a76ec2fef196507487329c12047bf6a68bca8ee9354155f4d01daf6eec5ff6bc";

	internal const string PublicKeyToken = "257b51d87d2e4d67";

	internal const string RootNamespace = "ProtoBuf";
}
namespace System.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, Inherited = false)]
	internal sealed class DynamicallyAccessedMembersAttribute : Attribute
	{
		public DynamicallyAccessedMemberTypes MemberTypes { get; }

		public DynamicallyAccessedMembersAttribute(DynamicallyAccessedMemberTypes memberTypes)
		{
			MemberTypes = memberTypes;
		}
	}
	[Flags]
	internal enum DynamicallyAccessedMemberTypes
	{
		None = 0,
		PublicParameterlessConstructor = 1,
		PublicConstructors = 3,
		NonPublicConstructors = 4,
		PublicMethods = 8,
		NonPublicMethods = 0x10,
		PublicFields = 0x20,
		NonPublicFields = 0x40,
		PublicNestedTypes = 0x80,
		NonPublicNestedTypes = 0x100,
		PublicProperties = 0x200,
		NonPublicProperties = 0x400,
		PublicEvents = 0x800,
		NonPublicEvents = 0x1000,
		All = -1
	}
}
namespace ProtoBuf
{
	internal enum TimeSpanScale
	{
		Days = 0,
		Hours = 1,
		Minutes = 2,
		Seconds = 3,
		Milliseconds = 4,
		Ticks = 5,
		MinMax = 15
	}
	internal static class BclHelpers
	{
		internal static readonly DateTime[] EpochOrigin = new DateTime[3]
		{
			new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified),
			new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc),
			new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Local)
		};

		private const int MAX_DECIMAL_BYTES = 32;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static object GetUninitializedObject(Type type)
		{
			return FormatterServices.GetUninitializedObject(type);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteTimeSpan(TimeSpan timeSpan, ProtoWriter dest)
		{
			ProtoWriter.State state = dest.DefaultState();
			WriteTimeSpanImpl(ref state, timeSpan, DateTimeKind.Unspecified);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteTimeSpan(ref ProtoWriter.State state, TimeSpan value)
		{
			WriteTimeSpanImpl(ref state, value, DateTimeKind.Unspecified);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteTimeSpanImpl(ref ProtoWriter.State state, TimeSpan timeSpan, DateTimeKind kind)
		{
			switch (state.WireType)
			{
			case WireType.String:
			case WireType.StartGroup:
			{
				PrimaryTypeProvider.ScaledTicks value = new PrimaryTypeProvider.ScaledTicks(timeSpan, kind);
				state.WriteMessage(SerializerFeatures.OptionSkipRecursionCheck, value, SerializerCache<PrimaryTypeProvider>.InstanceField);
				break;
			}
			case WireType.Fixed64:
				state.WriteInt64(timeSpan.Ticks);
				break;
			default:
				ProtoBuf.Internal.ThrowHelper.ThrowProtoException("Unexpected wire-type: " + state.WireType);
				break;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static TimeSpan ReadTimeSpan(ProtoReader source)
		{
			ProtoReader.State state = source.DefaultState();
			return ReadTimeSpan(ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static TimeSpan ReadTimeSpan(ref ProtoReader.State state)
		{
			switch (state.WireType)
			{
			case WireType.String:
			case WireType.StartGroup:
				return state.ReadMessage(SerializerFeatures.CategoryRepeated, default(PrimaryTypeProvider.ScaledTicks), SerializerCache<PrimaryTypeProvider>.InstanceField).ToTimeSpan();
			case WireType.Fixed64:
			{
				long num = state.ReadInt64();
				return num switch
				{
					long.MinValue => TimeSpan.MinValue, 
					long.MaxValue => TimeSpan.MaxValue, 
					_ => TimeSpan.FromTicks(num), 
				};
			}
			default:
				ProtoBuf.Internal.ThrowHelper.ThrowProtoException($"Unexpected wire-type: {state.WireType}");
				return default(TimeSpan);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static TimeSpan ReadDuration(ProtoReader source)
		{
			ProtoReader.State state = source.DefaultState();
			return ReadDuration(ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static TimeSpan ReadDuration(ref ProtoReader.State state)
		{
			return state.ReadMessage(SerializerFeatures.CategoryRepeated, default(Duration), SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDuration(TimeSpan value, ProtoWriter dest)
		{
			ProtoWriter.State state = dest.DefaultState();
			WriteDuration(ref state, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDuration(ref ProtoWriter.State state, TimeSpan value)
		{
			state.WriteMessage(SerializerFeatures.OptionSkipRecursionCheck, (Duration)value, (ISerializer<Duration>)SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static DateTime ReadTimestamp(ProtoReader source)
		{
			ProtoReader.State state = source.DefaultState();
			return ReadTimestamp(ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static DateTime ReadTimestamp(ref ProtoReader.State state)
		{
			return state.ReadMessage(SerializerFeatures.CategoryRepeated, default(Timestamp), SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteTimestamp(DateTime value, ProtoWriter dest)
		{
			ProtoWriter.State state = dest.DefaultState();
			WriteTimestamp(ref state, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteTimestamp(ref ProtoWriter.State state, DateTime value)
		{
			state.WriteMessage(SerializerFeatures.OptionSkipRecursionCheck, (Timestamp)value, (ISerializer<Timestamp>)SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static DateTime ReadDateTime(ProtoReader source)
		{
			ProtoReader.State state = source.DefaultState();
			return ReadDateTime(ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static DateTime ReadDateTime(ref ProtoReader.State state)
		{
			switch (state.WireType)
			{
			case WireType.String:
			case WireType.StartGroup:
				return state.ReadMessage(SerializerFeatures.CategoryRepeated, default(PrimaryTypeProvider.ScaledTicks), SerializerCache<PrimaryTypeProvider>.InstanceField).ToDateTime();
			case WireType.Fixed64:
			{
				long num = state.ReadInt64();
				return num switch
				{
					long.MinValue => DateTime.MinValue, 
					long.MaxValue => DateTime.MaxValue, 
					_ => EpochOrigin[0].AddTicks(num), 
				};
			}
			default:
				ProtoBuf.Internal.ThrowHelper.ThrowProtoException($"Unexpected wire-type: {state.WireType}");
				return default(DateTime);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDateTime(DateTime value, ProtoWriter dest)
		{
			ProtoWriter.State state = dest.DefaultState();
			WriteDateTimeImpl(ref state, value, includeKind: false);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDateTime(ref ProtoWriter.State state, DateTime value)
		{
			WriteDateTimeImpl(ref state, value, includeKind: false);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDateTimeWithKind(DateTime value, ProtoWriter dest)
		{
			ProtoWriter.State state = dest.DefaultState();
			WriteDateTimeImpl(ref state, value, includeKind: true);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDateTimeWithKind(ref ProtoWriter.State state, DateTime value)
		{
			WriteDateTimeImpl(ref state, value, includeKind: true);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static void WriteDateTimeImpl(ref ProtoWriter.State state, DateTime value, bool includeKind)
		{
			WireType wireType = state.WireType;
			TimeSpan timeSpan;
			if ((uint)(wireType - 2) <= 1u)
			{
				if (value == DateTime.MaxValue)
				{
					timeSpan = TimeSpan.MaxValue;
					includeKind = false;
				}
				else if (value == DateTime.MinValue)
				{
					timeSpan = TimeSpan.MinValue;
					includeKind = false;
				}
				else
				{
					timeSpan = value - EpochOrigin[0];
				}
			}
			else
			{
				timeSpan = value - EpochOrigin[0];
			}
			WriteTimeSpanImpl(ref state, timeSpan, includeKind ? value.Kind : DateTimeKind.Unspecified);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal ReadDecimal(ProtoReader reader)
		{
			ProtoReader.State state = reader.DefaultState();
			return ReadDecimal(ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static decimal ReadDecimal(ref ProtoReader.State state)
		{
			return state.ReadMessage(SerializerFeatures.CategoryRepeated, 0m, SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe static decimal ReadDecimalString(ref ProtoReader.State state)
		{
			byte* ptr = stackalloc byte[32];
			Span<byte> span = state.ReadBytes(new Span<byte>(ptr, 32));
			if (!Utf8Parser.TryParse((ReadOnlySpan<byte>)span, out decimal value, out int bytesConsumed, '\0') || bytesConsumed != span.Length)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Unable to parse decimal: '" + Encoding.UTF8.GetString(ptr, span.Length) + "'");
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDecimal(decimal value, ProtoWriter writer)
		{
			ProtoWriter.State state = writer.DefaultState();
			WriteDecimal(ref state, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDecimal(ref ProtoWriter.State state, decimal value)
		{
			state.WriteMessage(SerializerFeatures.OptionSkipRecursionCheck, value, SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDecimalString(ref ProtoWriter.State state, decimal value)
		{
			byte[] array = ArrayPool<byte>.Shared.Rent(32);
			try
			{
				if (!Utf8Formatter.TryFormat(value, array, out var bytesWritten))
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Unable to format decimal: '{value}'");
				}
				state.WriteBytes(new ReadOnlyMemory<byte>(array, 0, bytesWritten));
			}
			finally
			{
				ArrayPool<byte>.Shared.Return(array);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteGuid(Guid value, ProtoWriter dest)
		{
			ProtoWriter.State state = dest.DefaultState();
			WriteGuid(ref state, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteGuid(ref ProtoWriter.State state, Guid value)
		{
			state.WriteMessage(SerializerFeatures.OptionSkipRecursionCheck, value, SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteGuidBytes(ref ProtoWriter.State state, Guid value)
		{
			GuidHelper.Write(ref state, in value, asBytes: true);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteGuidString(ref ProtoWriter.State state, Guid value)
		{
			GuidHelper.Write(ref state, in value, asBytes: false);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Guid ReadGuid(ProtoReader source)
		{
			ProtoReader.State state = source.DefaultState();
			return ReadGuid(ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Guid ReadGuid(ref ProtoReader.State state)
		{
			return state.ReadMessage(SerializerFeatures.CategoryRepeated, default(Guid), SerializerCache<PrimaryTypeProvider>.InstanceField);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Guid ReadGuidBytes(ref ProtoReader.State state)
		{
			return GuidHelper.Read(ref state);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static Guid ReadGuidString(ref ProtoReader.State state)
		{
			return GuidHelper.Read(ref state);
		}
	}
	internal sealed class BufferExtension : IExtension, IExtensionResettable
	{
		private ArraySegment<byte> _buffer;

		internal Type Type { get; private set; }

		internal BufferExtension Tail { get; private set; }

		internal void SetTail(Type type, BufferExtension tail)
		{
			Type = type;
			Tail = tail;
		}

		void IExtensionResettable.Reset()
		{
			_buffer = default(ArraySegment<byte>);
		}

		int IExtension.GetLength()
		{
			return _buffer.Count;
		}

		Stream IExtension.BeginAppend()
		{
			return new MemoryStream();
		}

		void IExtension.EndAppend(Stream stream, bool commit)
		{
			using (stream)
			{
				if (!commit || !(stream is MemoryStream memoryStream) || !memoryStream.TryGetBuffer(out var buffer) || buffer.Count == 0)
				{
					return;
				}
				if (_buffer.Count == 0)
				{
					_buffer = buffer;
					return;
				}
				int num = _buffer.Offset + _buffer.Count;
				int num2 = _buffer.Array.Length - num;
				if (num2 >= buffer.Count)
				{
					Buffer.BlockCopy(buffer.Array, buffer.Offset, _buffer.Array, num, buffer.Count);
					_buffer = new ArraySegment<byte>(_buffer.Array, _buffer.Offset, num + buffer.Count);
					return;
				}
				byte[] array = new byte[_buffer.Count + buffer.Count];
				Buffer.BlockCopy(_buffer.Array, _buffer.Offset, array, 0, _buffer.Count);
				Buffer.BlockCopy(buffer.Array, buffer.Offset, array, _buffer.Count, buffer.Count);
				_buffer = new ArraySegment<byte>(array, 0, _buffer.Count + buffer.Count);
			}
		}

		Stream IExtension.BeginQuery()
		{
			if (_buffer.Count != 0)
			{
				return new MemoryStream(_buffer.Array, _buffer.Offset, _buffer.Count, writable: false, publiclyVisible: true);
			}
			return Stream.Null;
		}

		void IExtension.EndQuery(Stream stream)
		{
			using (stream)
			{
			}
		}
	}
	internal static class BufferPool
	{
		private static readonly ArrayPool<byte> _pool = ArrayPool<byte>.Shared;

		internal const int BUFFER_LENGTH = 1024;

		private const int MaxByteArraySize = 2147483591;

		internal static byte[] GetBuffer()
		{
			return GetBuffer(1024);
		}

		internal static byte[] GetBuffer(int minSize)
		{
			byte[] cachedBuffer = GetCachedBuffer(minSize);
			return cachedBuffer ?? new byte[minSize];
		}

		internal static byte[] GetCachedBuffer(int minSize)
		{
			return _pool.Rent(minSize);
		}

		internal static void ResizeAndFlushLeft(ref byte[] buffer, int toFitAtLeastBytes, int copyFromIndex, int copyBytes)
		{
			int num = buffer.Length * 2;
			if (num < 0)
			{
				num = 2147483591;
			}
			if (num < toFitAtLeastBytes)
			{
				num = toFitAtLeastBytes;
			}
			if (copyBytes == 0)
			{
				ReleaseBufferToPool(ref buffer);
			}
			byte[] array = GetCachedBuffer(num) ?? new byte[num];
			if (copyBytes > 0)
			{
				Buffer.BlockCopy(buffer, copyFromIndex, array, 0, copyBytes);
				ReleaseBufferToPool(ref buffer);
			}
			buffer = array;
		}

		internal static void ReleaseBufferToPool(ref byte[] buffer)
		{
			byte[] array = buffer;
			buffer = null;
			if (array != null)
			{
				_pool.Return(array);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	[ImmutableObject(true)]
	internal sealed class ProtoBeforeSerializationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	[ImmutableObject(true)]
	internal sealed class ProtoAfterSerializationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	[ImmutableObject(true)]
	internal sealed class ProtoBeforeDeserializationAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	[ImmutableObject(true)]
	internal sealed class ProtoAfterDeserializationAttribute : Attribute
	{
	}
	internal enum CompatibilityLevel
	{
		NotSpecified = 0,
		Level200 = 200,
		Level240 = 240,
		Level300 = 300
	}
	[ImmutableObject(true)]
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Interface, AllowMultiple = false, Inherited = true)]
	internal sealed class CompatibilityLevelAttribute : Attribute
	{
		public CompatibilityLevel Level { get; }

		public CompatibilityLevelAttribute(CompatibilityLevel level)
		{
			Level = level;
		}

		internal static void AssertValid(CompatibilityLevel compatibilityLevel)
		{
			switch (compatibilityLevel)
			{
			case CompatibilityLevel.NotSpecified:
			case CompatibilityLevel.Level200:
			case CompatibilityLevel.Level240:
			case CompatibilityLevel.Level300:
				return;
			}
			Throw(compatibilityLevel);
			static void Throw(CompatibilityLevel compatibilityLevel)
			{
				throw new ArgumentOutOfRangeException("compatibilityLevel", $"Compatiblity level '{compatibilityLevel}' is not recognized.");
			}
		}
	}
	internal enum DataFormat
	{
		Default,
		ZigZag,
		TwosComplement,
		FixedSize,
		Group,
		[Obsolete("This option is replaced with CompatibilityLevel, and is only used for Level200, where it changes this field to Level240", false)]
		WellKnown
	}
	[Serializable]
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct DiscriminatedUnionObject : ISerializable
	{
		public readonly object Object;

		public int Discriminator { get; }

		public bool Is(int discriminator)
		{
			return Discriminator == discriminator;
		}

		public DiscriminatedUnionObject(int discriminator, object value)
		{
			Discriminator = discriminator;
			Object = value;
		}

		public static void Reset(ref DiscriminatedUnionObject value, int discriminator)
		{
			if (value.Discriminator == discriminator)
			{
				value = default(DiscriminatedUnionObject);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (Discriminator != 0)
			{
				info.AddValue("d", Discriminator);
			}
			if (Object != null)
			{
				info.AddValue("o", Object);
			}
		}

		private DiscriminatedUnionObject(SerializationInfo info, StreamingContext context)
		{
			this = default(DiscriminatedUnionObject);
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				SerializationEntry current = enumerator.Current;
				string name = current.Name;
				if (!(name == "d"))
				{
					if (name == "o")
					{
						Object = current.Value;
					}
				}
				else
				{
					Discriminator = (int)current.Value;
				}
			}
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	internal readonly struct DiscriminatedUnion64 : ISerializable
	{
		[FieldOffset(0)]
		private readonly int _discriminator;

		[FieldOffset(8)]
		public readonly long Int64;

		[FieldOffset(8)]
		public readonly ulong UInt64;

		[FieldOffset(8)]
		public readonly int Int32;

		[FieldOffset(8)]
		public readonly uint UInt32;

		[FieldOffset(8)]
		public readonly bool Boolean;

		[FieldOffset(8)]
		public readonly float Single;

		[FieldOffset(8)]
		public readonly double Double;

		[FieldOffset(8)]
		public readonly DateTime DateTime;

		[FieldOffset(8)]
		public readonly TimeSpan TimeSpan;

		public int Discriminator => _discriminator;

		private DiscriminatedUnion64(int discriminator)
		{
			this = default(DiscriminatedUnion64);
			_discriminator = discriminator;
		}

		public bool Is(int discriminator)
		{
			return _discriminator == discriminator;
		}

		public DiscriminatedUnion64(int discriminator, long value)
			: this(discriminator)
		{
			Int64 = value;
		}

		public DiscriminatedUnion64(int discriminator, int value)
			: this(discriminator)
		{
			Int32 = value;
		}

		public DiscriminatedUnion64(int discriminator, ulong value)
			: this(discriminator)
		{
			UInt64 = value;
		}

		public DiscriminatedUnion64(int discriminator, uint value)
			: this(discriminator)
		{
			UInt32 = value;
		}

		public DiscriminatedUnion64(int discriminator, float value)
			: this(discriminator)
		{
			Single = value;
		}

		public DiscriminatedUnion64(int discriminator, double value)
			: this(discriminator)
		{
			Double = value;
		}

		public DiscriminatedUnion64(int discriminator, bool value)
			: this(discriminator)
		{
			Boolean = value;
		}

		public DiscriminatedUnion64(int discriminator, DateTime? value)
			: this(value.HasValue ? discriminator : 0)
		{
			DateTime = value.GetValueOrDefault();
		}

		public DiscriminatedUnion64(int discriminator, TimeSpan? value)
			: this(value.HasValue ? discriminator : 0)
		{
			TimeSpan = value.GetValueOrDefault();
		}

		public static void Reset(ref DiscriminatedUnion64 value, int discriminator)
		{
			if (value.Discriminator == discriminator)
			{
				value = default(DiscriminatedUnion64);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (_discriminator != 0)
			{
				info.AddValue("d", _discriminator);
			}
			if (Int64 != 0L)
			{
				info.AddValue("i", Int64);
			}
		}

		private DiscriminatedUnion64(SerializationInfo info, StreamingContext context)
		{
			this = default(DiscriminatedUnion64);
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				SerializationEntry current = enumerator.Current;
				string name = current.Name;
				if (!(name == "d"))
				{
					if (name == "i")
					{
						Int64 = (long)current.Value;
					}
				}
				else
				{
					_discriminator = (int)current.Value;
				}
			}
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	internal readonly struct DiscriminatedUnion128Object : ISerializable
	{
		[FieldOffset(0)]
		private readonly int _discriminator;

		[FieldOffset(8)]
		public readonly long Int64;

		[FieldOffset(8)]
		public readonly ulong UInt64;

		[FieldOffset(8)]
		public readonly int Int32;

		[FieldOffset(8)]
		public readonly uint UInt32;

		[FieldOffset(8)]
		public readonly bool Boolean;

		[FieldOffset(8)]
		public readonly float Single;

		[FieldOffset(8)]
		public readonly double Double;

		[FieldOffset(8)]
		public readonly DateTime DateTime;

		[FieldOffset(8)]
		public readonly TimeSpan TimeSpan;

		[FieldOffset(8)]
		public readonly Guid Guid;

		[FieldOffset(24)]
		public readonly object Object;

		[FieldOffset(8)]
		private readonly long _lo;

		[FieldOffset(16)]
		private readonly long _hi;

		public int Discriminator => _discriminator;

		private DiscriminatedUnion128Object(int discriminator)
		{
			this = default(DiscriminatedUnion128Object);
			_discriminator = discriminator;
		}

		public bool Is(int discriminator)
		{
			return _discriminator == discriminator;
		}

		public DiscriminatedUnion128Object(int discriminator, long value)
			: this(discriminator)
		{
			Int64 = value;
		}

		public DiscriminatedUnion128Object(int discriminator, int value)
			: this(discriminator)
		{
			Int32 = value;
		}

		public DiscriminatedUnion128Object(int discriminator, ulong value)
			: this(discriminator)
		{
			UInt64 = value;
		}

		public DiscriminatedUnion128Object(int discriminator, uint value)
			: this(discriminator)
		{
			UInt32 = value;
		}

		public DiscriminatedUnion128Object(int discriminator, float value)
			: this(discriminator)
		{
			Single = value;
		}

		public DiscriminatedUnion128Object(int discriminator, double value)
			: this(discriminator)
		{
			Double = value;
		}

		public DiscriminatedUnion128Object(int discriminator, bool value)
			: this(discriminator)
		{
			Boolean = value;
		}

		public DiscriminatedUnion128Object(int discriminator, object value)
			: this((value != null) ? discriminator : 0)
		{
			Object = value;
		}

		public DiscriminatedUnion128Object(int discriminator, DateTime? value)
			: this(value.HasValue ? discriminator : 0)
		{
			DateTime = value.GetValueOrDefault();
		}

		public DiscriminatedUnion128Object(int discriminator, TimeSpan? value)
			: this(value.HasValue ? discriminator : 0)
		{
			TimeSpan = value.GetValueOrDefault();
		}

		public DiscriminatedUnion128Object(int discriminator, Guid? value)
			: this(value.HasValue ? discriminator : 0)
		{
			Guid = value.GetValueOrDefault();
		}

		public static void Reset(ref DiscriminatedUnion128Object value, int discriminator)
		{
			if (value.Discriminator == discriminator)
			{
				value = default(DiscriminatedUnion128Object);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (_discriminator != 0)
			{
				info.AddValue("d", _discriminator);
			}
			if (_lo != 0L)
			{
				info.AddValue("l", _lo);
			}
			if (_hi != 0L)
			{
				info.AddValue("h", _hi);
			}
			if (Object != null)
			{
				info.AddValue("o", Object);
			}
		}

		private DiscriminatedUnion128Object(SerializationInfo info, StreamingContext context)
		{
			this = default(DiscriminatedUnion128Object);
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				SerializationEntry current = enumerator.Current;
				switch (current.Name)
				{
				case "d":
					_discriminator = (int)current.Value;
					break;
				case "l":
					_lo = (long)current.Value;
					break;
				case "h":
					_hi = (long)current.Value;
					break;
				case "o":
					Object = current.Value;
					break;
				}
			}
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	internal readonly struct DiscriminatedUnion128 : ISerializable
	{
		[FieldOffset(0)]
		private readonly int _discriminator;

		[FieldOffset(8)]
		public readonly long Int64;

		[FieldOffset(8)]
		public readonly ulong UInt64;

		[FieldOffset(8)]
		public readonly int Int32;

		[FieldOffset(8)]
		public readonly uint UInt32;

		[FieldOffset(8)]
		public readonly bool Boolean;

		[FieldOffset(8)]
		public readonly float Single;

		[FieldOffset(8)]
		public readonly double Double;

		[FieldOffset(8)]
		public readonly DateTime DateTime;

		[FieldOffset(8)]
		public readonly TimeSpan TimeSpan;

		[FieldOffset(8)]
		public readonly Guid Guid;

		[FieldOffset(8)]
		private readonly long _lo;

		[FieldOffset(16)]
		private readonly long _hi;

		public int Discriminator => _discriminator;

		private DiscriminatedUnion128(int discriminator)
		{
			this = default(DiscriminatedUnion128);
			_discriminator = discriminator;
		}

		public bool Is(int discriminator)
		{
			return _discriminator == discriminator;
		}

		public DiscriminatedUnion128(int discriminator, long value)
			: this(discriminator)
		{
			Int64 = value;
		}

		public DiscriminatedUnion128(int discriminator, int value)
			: this(discriminator)
		{
			Int32 = value;
		}

		public DiscriminatedUnion128(int discriminator, ulong value)
			: this(discriminator)
		{
			UInt64 = value;
		}

		public DiscriminatedUnion128(int discriminator, uint value)
			: this(discriminator)
		{
			UInt32 = value;
		}

		public DiscriminatedUnion128(int discriminator, float value)
			: this(discriminator)
		{
			Single = value;
		}

		public DiscriminatedUnion128(int discriminator, double value)
			: this(discriminator)
		{
			Double = value;
		}

		public DiscriminatedUnion128(int discriminator, bool value)
			: this(discriminator)
		{
			Boolean = value;
		}

		public DiscriminatedUnion128(int discriminator, DateTime? value)
			: this(value.HasValue ? discriminator : 0)
		{
			DateTime = value.GetValueOrDefault();
		}

		public DiscriminatedUnion128(int discriminator, TimeSpan? value)
			: this(value.HasValue ? discriminator : 0)
		{
			TimeSpan = value.GetValueOrDefault();
		}

		public DiscriminatedUnion128(int discriminator, Guid? value)
			: this(value.HasValue ? discriminator : 0)
		{
			Guid = value.GetValueOrDefault();
		}

		public static void Reset(ref DiscriminatedUnion128 value, int discriminator)
		{
			if (value.Discriminator == discriminator)
			{
				value = default(DiscriminatedUnion128);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (_discriminator != 0)
			{
				info.AddValue("d", _discriminator);
			}
			if (_lo != 0L)
			{
				info.AddValue("l", _lo);
			}
			if (_hi != 0L)
			{
				info.AddValue("h", _hi);
			}
		}

		private DiscriminatedUnion128(SerializationInfo info, StreamingContext context)
		{
			this = default(DiscriminatedUnion128);
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				SerializationEntry current = enumerator.Current;
				switch (current.Name)
				{
				case "d":
					_discriminator = (int)current.Value;
					break;
				case "l":
					_lo = (long)current.Value;
					break;
				case "h":
					_hi = (long)current.Value;
					break;
				}
			}
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	internal readonly struct DiscriminatedUnion64Object : ISerializable
	{
		[FieldOffset(0)]
		private readonly int _discriminator;

		[FieldOffset(8)]
		public readonly long Int64;

		[FieldOffset(8)]
		public readonly ulong UInt64;

		[FieldOffset(8)]
		public readonly int Int32;

		[FieldOffset(8)]
		public readonly uint UInt32;

		[FieldOffset(8)]
		public readonly bool Boolean;

		[FieldOffset(8)]
		public readonly float Single;

		[FieldOffset(8)]
		public readonly double Double;

		[FieldOffset(8)]
		public readonly DateTime DateTime;

		[FieldOffset(8)]
		public readonly TimeSpan TimeSpan;

		[FieldOffset(16)]
		public readonly object Object;

		public int Discriminator => _discriminator;

		private DiscriminatedUnion64Object(int discriminator)
		{
			this = default(DiscriminatedUnion64Object);
			_discriminator = discriminator;
		}

		public bool Is(int discriminator)
		{
			return _discriminator == discriminator;
		}

		public DiscriminatedUnion64Object(int discriminator, long value)
			: this(discriminator)
		{
			Int64 = value;
		}

		public DiscriminatedUnion64Object(int discriminator, int value)
			: this(discriminator)
		{
			Int32 = value;
		}

		public DiscriminatedUnion64Object(int discriminator, ulong value)
			: this(discriminator)
		{
			UInt64 = value;
		}

		public DiscriminatedUnion64Object(int discriminator, uint value)
			: this(discriminator)
		{
			UInt32 = value;
		}

		public DiscriminatedUnion64Object(int discriminator, float value)
			: this(discriminator)
		{
			Single = value;
		}

		public DiscriminatedUnion64Object(int discriminator, double value)
			: this(discriminator)
		{
			Double = value;
		}

		public DiscriminatedUnion64Object(int discriminator, bool value)
			: this(discriminator)
		{
			Boolean = value;
		}

		public DiscriminatedUnion64Object(int discriminator, object value)
			: this((value != null) ? discriminator : 0)
		{
			Object = value;
		}

		public DiscriminatedUnion64Object(int discriminator, DateTime? value)
			: this(value.HasValue ? discriminator : 0)
		{
			DateTime = value.GetValueOrDefault();
		}

		public DiscriminatedUnion64Object(int discriminator, TimeSpan? value)
			: this(value.HasValue ? discriminator : 0)
		{
			TimeSpan = value.GetValueOrDefault();
		}

		public static void Reset(ref DiscriminatedUnion64Object value, int discriminator)
		{
			if (value.Discriminator == discriminator)
			{
				value = default(DiscriminatedUnion64Object);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (_discriminator != 0)
			{
				info.AddValue("d", _discriminator);
			}
			if (Int64 != 0L)
			{
				info.AddValue("i", Int64);
			}
			if (Object != null)
			{
				info.AddValue("o", Object);
			}
		}

		private DiscriminatedUnion64Object(SerializationInfo info, StreamingContext context)
		{
			this = default(DiscriminatedUnion64Object);
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				SerializationEntry current = enumerator.Current;
				switch (current.Name)
				{
				case "d":
					_discriminator = (int)current.Value;
					break;
				case "i":
					Int64 = (long)current.Value;
					break;
				case "o":
					Object = current.Value;
					break;
				}
			}
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	internal readonly struct DiscriminatedUnion32 : ISerializable
	{
		[FieldOffset(0)]
		private readonly int _discriminator;

		[FieldOffset(4)]
		public readonly int Int32;

		[FieldOffset(4)]
		public readonly uint UInt32;

		[FieldOffset(4)]
		public readonly bool Boolean;

		[FieldOffset(4)]
		public readonly float Single;

		public int Discriminator => _discriminator;

		private DiscriminatedUnion32(int discriminator)
		{
			this = default(DiscriminatedUnion32);
			_discriminator = discriminator;
		}

		public bool Is(int discriminator)
		{
			return _discriminator == discriminator;
		}

		public DiscriminatedUnion32(int discriminator, int value)
			: this(discriminator)
		{
			Int32 = value;
		}

		public DiscriminatedUnion32(int discriminator, uint value)
			: this(discriminator)
		{
			UInt32 = value;
		}

		public DiscriminatedUnion32(int discriminator, float value)
			: this(discriminator)
		{
			Single = value;
		}

		public DiscriminatedUnion32(int discriminator, bool value)
			: this(discriminator)
		{
			Boolean = value;
		}

		public static void Reset(ref DiscriminatedUnion32 value, int discriminator)
		{
			if (value.Discriminator == discriminator)
			{
				value = default(DiscriminatedUnion32);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (_discriminator != 0)
			{
				info.AddValue("d", _discriminator);
			}
			if (Int32 != 0)
			{
				info.AddValue("i", Int32);
			}
		}

		private DiscriminatedUnion32(SerializationInfo info, StreamingContext context)
		{
			this = default(DiscriminatedUnion32);
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				SerializationEntry current = enumerator.Current;
				string name = current.Name;
				if (!(name == "d"))
				{
					if (name == "i")
					{
						Int32 = (int)current.Value;
					}
				}
				else
				{
					_discriminator = (int)current.Value;
				}
			}
		}
	}
	[Serializable]
	[StructLayout(LayoutKind.Explicit)]
	internal readonly struct DiscriminatedUnion32Object : ISerializable
	{
		[FieldOffset(0)]
		private readonly int _discriminator;

		[FieldOffset(4)]
		public readonly int Int32;

		[FieldOffset(4)]
		public readonly uint UInt32;

		[FieldOffset(4)]
		public readonly bool Boolean;

		[FieldOffset(4)]
		public readonly float Single;

		[FieldOffset(8)]
		public readonly object Object;

		public int Discriminator => _discriminator;

		private DiscriminatedUnion32Object(int discriminator)
		{
			this = default(DiscriminatedUnion32Object);
			_discriminator = discriminator;
		}

		public bool Is(int discriminator)
		{
			return _discriminator == discriminator;
		}

		public DiscriminatedUnion32Object(int discriminator, int value)
			: this(discriminator)
		{
			Int32 = value;
		}

		public DiscriminatedUnion32Object(int discriminator, uint value)
			: this(discriminator)
		{
			UInt32 = value;
		}

		public DiscriminatedUnion32Object(int discriminator, float value)
			: this(discriminator)
		{
			Single = value;
		}

		public DiscriminatedUnion32Object(int discriminator, bool value)
			: this(discriminator)
		{
			Boolean = value;
		}

		public DiscriminatedUnion32Object(int discriminator, object value)
			: this((value != null) ? discriminator : 0)
		{
			Object = value;
		}

		public static void Reset(ref DiscriminatedUnion32Object value, int discriminator)
		{
			if (value.Discriminator == discriminator)
			{
				value = default(DiscriminatedUnion32Object);
			}
		}

		void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)
		{
			if (_discriminator != 0)
			{
				info.AddValue("d", _discriminator);
			}
			if (Int32 != 0)
			{
				info.AddValue("i", Int32);
			}
			if (Object != null)
			{
				info.AddValue("o", Object);
			}
		}

		private DiscriminatedUnion32Object(SerializationInfo info, StreamingContext context)
		{
			this = default(DiscriminatedUnion32Object);
			SerializationInfoEnumerator enumerator = info.GetEnumerator();
			while (enumerator.MoveNext())
			{
				SerializationEntry current = enumerator.Current;
				switch (current.Name)
				{
				case "d":
					_discriminator = (int)current.Value;
					break;
				case "i":
					Int32 = (int)current.Value;
					break;
				case "o":
					Object = current.Value;
					break;
				}
			}
		}
	}
	internal abstract class Extensible : ITypedExtensible, IExtensible
	{
		private IExtension extensionObject;

		IExtension IExtensible.GetExtensionObject(bool createIfMissing)
		{
			return GetExtensionObject(createIfMissing);
		}

		IExtension ITypedExtensible.GetExtensionObject(Type type, bool createIfMissing)
		{
			if ((object)type != GetType())
			{
				return GetExtensionObject(ref extensionObject, type, createIfMissing);
			}
			return GetExtensionObject(createIfMissing);
		}

		[Obsolete("This API is considered, and may no longer be used in all scenarios (in particular when inheritance is involved); it is not recommended to rely on this API")]
		protected virtual IExtension GetExtensionObject(bool createIfMissing)
		{
			return GetExtensionObject(ref extensionObject, GetType(), createIfMissing);
		}

		public static IExtension GetExtensionObject(ref IExtension extensionObject, Type type, bool createIfMissing)
		{
			if ((object)type == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("type");
			}
			BufferExtension bufferExtension = extensionObject as BufferExtension;
			BufferExtension bufferExtension2 = bufferExtension;
			if (bufferExtension == null)
			{
				if (extensionObject != null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("Custom extension implementations should not be passed to GetExtensionObject");
				}
			}
			else
			{
				while (bufferExtension2 != null)
				{
					Type type2 = bufferExtension2.Type;
					if ((object)type2 == null)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Typed and untyped extension data cannot be mixed");
					}
					if ((object)type2 == type)
					{
						return bufferExtension2;
					}
					bufferExtension2 = bufferExtension2.Tail;
				}
			}
			if (createIfMissing)
			{
				BufferExtension bufferExtension3 = new BufferExtension();
				bufferExtension3.SetTail(type, bufferExtension);
				bufferExtension2 = (BufferExtension)(extensionObject = bufferExtension3);
			}
			return bufferExtension2;
		}

		public static IExtension GetExtensionObject(ref IExtension extensionObject, bool createIfMissing)
		{
			if (extensionObject == null)
			{
				if (createIfMissing)
				{
					extensionObject = new BufferExtension();
				}
			}
			else if (extensionObject is BufferExtension bufferExtension && (object)bufferExtension.Type != null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Typed and untyped extension data cannot be mixed");
			}
			return extensionObject;
		}

		public static void AppendValue<TValue>(IExtensible instance, int tag, TValue value)
		{
			ExtensibleUtil.AppendExtendValue(null, instance, tag, DataFormat.Default, value);
		}

		public static void AppendValue<TValue>(IExtensible instance, int tag, DataFormat format, TValue value)
		{
			ExtensibleUtil.AppendExtendValue(null, instance, tag, format, value);
		}

		public static void AppendValue<TValue>(TypeModel model, IExtensible instance, int tag, TValue value, DataFormat format = DataFormat.Default)
		{
			ExtensibleUtil.AppendExtendValue(model, instance, tag, format, value);
		}

		public static TValue GetValue<TValue>(IExtensible instance, int tag)
		{
			return GetValue<TValue>(null, instance, tag);
		}

		public static TValue GetValue<TValue>(IExtensible instance, int tag, DataFormat format)
		{
			return GetValue<TValue>(null, instance, tag, format);
		}

		public static TValue GetValue<TValue>(TypeModel model, IExtensible instance, int tag, DataFormat format = DataFormat.Default)
		{
			if (!TryGetValue<TValue>(model, instance, tag, out var value, format))
			{
				return default(TValue);
			}
			return value;
		}

		public static bool TryGetValue<TValue>(IExtensible instance, int tag, out TValue value)
		{
			return TryGetValue<TValue>(null, instance, tag, out value);
		}

		public static bool TryGetValue<TValue>(IExtensible instance, int tag, DataFormat format, out TValue value)
		{
			return TryGetValue<TValue>(null, instance, tag, out value, format);
		}

		public static bool TryGetValue<TValue>(IExtensible instance, int tag, DataFormat format, bool allowDefinedTag, out TValue value)
		{
			return TryGetValue<TValue>(null, instance, tag, out value, format, allowDefinedTag);
		}

		public static bool TryGetValue<TValue>(TypeModel model, IExtensible instance, int tag, out TValue value, DataFormat format = DataFormat.Default, bool allowDefinedTag = false)
		{
			value = default(TValue);
			bool result = false;
			foreach (TValue extendedValue in ExtensibleUtil.GetExtendedValues<TValue>(model, instance, tag, format, singleton: true, allowDefinedTag))
			{
				value = extendedValue;
				result = true;
			}
			return result;
		}

		public static IEnumerable<TValue> GetValues<TValue>(IExtensible instance, int tag)
		{
			return ExtensibleUtil.GetExtendedValues<TValue>(null, instance, tag, DataFormat.Default, singleton: false, allowDefinedTag: false);
		}

		public static IEnumerable<TValue> GetValues<TValue>(IExtensible instance, int tag, DataFormat format)
		{
			return ExtensibleUtil.GetExtendedValues<TValue>(null, instance, tag, format, singleton: false, allowDefinedTag: false);
		}

		public static IEnumerable<TValue> GetValues<TValue>(TypeModel model, IExtensible instance, int tag, DataFormat format = DataFormat.Default)
		{
			return ExtensibleUtil.GetExtendedValues<TValue>(model, instance, tag, format, singleton: false, allowDefinedTag: false);
		}

		public static bool TryGetValue(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool allowDefinedTag, out object value)
		{
			value = null;
			bool result = false;
			foreach (object extendedValue in ExtensibleUtil.GetExtendedValues(model, type, instance, tag, format, singleton: true, allowDefinedTag))
			{
				value = extendedValue;
				result = true;
			}
			return result;
		}

		public static IEnumerable GetValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format = DataFormat.Default)
		{
			return ExtensibleUtil.GetExtendedValues(model, type, instance, tag, format, singleton: false, allowDefinedTag: false);
		}

		public static void AppendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value)
		{
			ExtensibleUtil.AppendExtendValue(model, instance, tag, format, value);
		}
	}
	internal static class ExtensibleUtil
	{
		internal static IEnumerable<TValue> GetExtendedValues<TValue>(TypeModel model, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag)
		{
			foreach (TValue extendedValue in GetExtendedValues(model, typeof(TValue), instance, tag, format, singleton, allowDefinedTag))
			{
				yield return extendedValue;
			}
		}

		internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtensible instance, int tag, DataFormat format, bool singleton, bool allowDefinedTag)
		{
			if (instance == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("instance");
			}
			if (tag <= 0)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("tag");
			}
			return GetExtendedValues(model, type, instance.GetExtensionObject(createIfMissing: false), tag, format, singleton);
		}

		internal static IEnumerable GetExtendedValues(TypeModel model, Type type, IExtension extn, int tag, DataFormat format, bool singleton)
		{
			if (model == null)
			{
				model = TypeModel.DefaultModel;
			}
			if (extn == null)
			{
				yield break;
			}
			Stream stream = extn.BeginQuery();
			try
			{
				object value = null;
				SerializationContext userState = new SerializationContext();
				ProtoReader.SolidState state = ProtoReader.State.Create(stream, model, userState, -1L).Solidify();
				try
				{
					while (model.TryDeserializeAuxiliaryType(ref state, format, tag, type, ref value, skipOtherFields: true, asListItem: true, autoCreate: false, insideList: false, null, isRoot: false) && value != null)
					{
						if (!singleton)
						{
							yield return value;
							value = null;
						}
					}
					if (singleton && value != null)
					{
						yield return value;
					}
				}
				finally
				{
					state.Dispose();
				}
			}
			finally
			{
				extn.EndQuery(stream);
			}
		}

		internal static void AppendExtendValue(TypeModel model, IExtensible instance, int tag, DataFormat format, object value)
		{
			if (instance == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("instance");
			}
			if (value == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("value");
			}
			AppendExtendValue(model, instance.GetExtensionObject(createIfMissing: true), tag, format, value);
		}

		internal static void AppendExtendValue(TypeModel model, IExtension extn, int tag, DataFormat format, object value)
		{
			if (model == null)
			{
				model = TypeModel.DefaultModel;
			}
			if (extn == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("No extension object available; appended data would be lost.");
			}
			bool commit = false;
			Stream stream = extn.BeginAppend();
			try
			{
				ProtoWriter.State state = ProtoWriter.State.Create(stream, model);
				try
				{
					model.TrySerializeAuxiliaryType(ref state, null, format, tag, value, isInsideList: false, null, isRoot: false);
					state.Close();
				}
				catch
				{
					state.Abandon();
					throw;
				}
				finally
				{
					state.Dispose();
				}
				commit = true;
			}
			finally
			{
				extn.EndAppend(stream, commit);
			}
		}
	}
	internal static class Helpers
	{
		internal static MethodInfo GetInstanceMethod(Type declaringType, string name)
		{
			return declaringType.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}

		internal static MethodInfo GetStaticMethod(Type declaringType, string name)
		{
			return declaringType.GetMethod(name, BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		}

		internal static MethodInfo GetInstanceMethod(Type declaringType, string name, Type[] types)
		{
			if (types == null)
			{
				types = Type.EmptyTypes;
			}
			return declaringType.GetMethod(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, types, null);
		}

		internal static bool IsSubclassOf(Type type, Type baseClass)
		{
			return type.IsSubclassOf(baseClass);
		}

		public static ProtoTypeCode GetTypeCode(Type type)
		{
			TypeCode typeCode = Type.GetTypeCode(type);
			switch (typeCode)
			{
			case TypeCode.Empty:
			case TypeCode.Boolean:
			case TypeCode.Char:
			case TypeCode.SByte:
			case TypeCode.Byte:
			case TypeCode.Int16:
			case TypeCode.UInt16:
			case TypeCode.Int32:
			case TypeCode.UInt32:
			case TypeCode.Int64:
			case TypeCode.UInt64:
			case TypeCode.Single:
			case TypeCode.Double:
			case TypeCode.Decimal:
			case TypeCode.DateTime:
			case TypeCode.String:
				return (ProtoTypeCode)typeCode;
			default:
				if (type == typeof(TimeSpan))
				{
					return ProtoTypeCode.TimeSpan;
				}
				if (type == typeof(Guid))
				{
					return ProtoTypeCode.Guid;
				}
				if (type == typeof(Uri))
				{
					return ProtoTypeCode.Uri;
				}
				if (type == typeof(byte[]))
				{
					return ProtoTypeCode.ByteArray;
				}
				if (type == typeof(ArraySegment<byte>))
				{
					return ProtoTypeCode.ByteArraySegment;
				}
				if (type == typeof(Memory<byte>))
				{
					return ProtoTypeCode.ByteMemory;
				}
				if (type == typeof(ReadOnlyMemory<byte>))
				{
					return ProtoTypeCode.ByteReadOnlyMemory;
				}
				if (type == typeof(Type))
				{
					return ProtoTypeCode.Type;
				}
				if (type == typeof(IntPtr))
				{
					return ProtoTypeCode.IntPtr;
				}
				if (type == typeof(UIntPtr))
				{
					return ProtoTypeCode.UIntPtr;
				}
				return ProtoTypeCode.Unknown;
			}
		}

		internal static MethodInfo GetGetMethod(PropertyInfo property, bool nonPublic, bool allowInternal)
		{
			if ((object)property == null)
			{
				return null;
			}
			MethodInfo methodInfo = property.GetGetMethod(nonPublic);
			if ((object)methodInfo == null && !nonPublic && allowInternal)
			{
				methodInfo = property.GetGetMethod(nonPublic: true);
				if ((object)methodInfo != null && !methodInfo.IsAssembly && !methodInfo.IsFamilyOrAssembly)
				{
					methodInfo = null;
				}
			}
			return methodInfo;
		}

		internal static MethodInfo GetSetMethod(PropertyInfo property, bool nonPublic, bool allowInternal)
		{
			if ((object)property == null)
			{
				return null;
			}
			MethodInfo methodInfo = property.GetSetMethod(nonPublic);
			if ((object)methodInfo == null && !nonPublic && allowInternal)
			{
				methodInfo = property.GetGetMethod(nonPublic: true);
				if ((object)methodInfo != null && !methodInfo.IsAssembly && !methodInfo.IsFamilyOrAssembly)
				{
					methodInfo = null;
				}
			}
			return methodInfo;
		}

		internal static ConstructorInfo GetConstructor(Type type, Type[] parameterTypes, bool nonPublic)
		{
			return type.GetConstructor(nonPublic ? (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : (BindingFlags.Instance | BindingFlags.Public), null, parameterTypes, null);
		}

		internal static ConstructorInfo[] GetConstructors(Type type, bool nonPublic)
		{
			return type.GetConstructors(nonPublic ? (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : (BindingFlags.Instance | BindingFlags.Public));
		}

		internal static void GetBuffer(MemoryStream stream, out ArraySegment<byte> segment)
		{
			if (stream == null || !stream.TryGetBuffer(out segment))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Unable to obtain buffer from MemoryStream");
				segment = default(ArraySegment<byte>);
			}
		}

		internal static PropertyInfo GetProperty(Type type, string name, bool nonPublic)
		{
			return type.GetProperty(name, nonPublic ? (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic) : (BindingFlags.Instance | BindingFlags.Public));
		}

		internal static MemberInfo[] GetInstanceFieldsAndProperties(Type type, bool publicOnly)
		{
			BindingFlags bindingAttr = (publicOnly ? (BindingFlags.Instance | BindingFlags.Public) : (BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic));
			PropertyInfo[] properties = type.GetProperties(bindingAttr);
			FieldInfo[] fields = type.GetFields(bindingAttr);
			MemberInfo[] array = new MemberInfo[fields.Length + properties.Length];
			properties.CopyTo(array, 0);
			fields.CopyTo(array, properties.Length);
			return array;
		}

		internal static Type GetMemberType(MemberInfo member)
		{
			return member.MemberType switch
			{
				MemberTypes.Field => ((FieldInfo)member).FieldType, 
				MemberTypes.Property => ((PropertyInfo)member).PropertyType, 
				_ => null, 
			};
		}
	}
	internal enum ProtoTypeCode
	{
		Empty = 0,
		Unknown = 1,
		Boolean = 3,
		Char = 4,
		SByte = 5,
		Byte = 6,
		Int16 = 7,
		UInt16 = 8,
		Int32 = 9,
		UInt32 = 10,
		Int64 = 11,
		UInt64 = 12,
		Single = 13,
		Double = 14,
		Decimal = 15,
		DateTime = 16,
		String = 18,
		TimeSpan = 100,
		ByteArray = 101,
		Guid = 102,
		Uri = 103,
		Type = 104,
		ByteArraySegment = 105,
		ByteMemory = 106,
		ByteReadOnlyMemory = 107,
		IntPtr = 108,
		UIntPtr = 109
	}
	internal interface IExtensible
	{
		IExtension GetExtensionObject(bool createIfMissing);
	}
	internal interface ITypedExtensible
	{
		IExtension GetExtensionObject(Type type, bool createIfMissing);
	}
	internal interface IExtension
	{
		Stream BeginAppend();

		void EndAppend(Stream stream, bool commit);

		Stream BeginQuery();

		void EndQuery(Stream stream);

		int GetLength();
	}
	internal interface IExtensionResettable : IExtension
	{
		void Reset();
	}
	internal enum ImplicitFields
	{
		None,
		AllPublic,
		AllFields
	}
	internal interface IProtoInput<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TInput>
	{
		T Deserialize<T>(TInput source, T value = default(T), object userState = null);
	}
	internal interface IProtoOutput<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TOutput>
	{
		void Serialize<T>(TOutput destination, T value, object userState = null);
	}
	internal interface IMeasuredProtoOutput<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TOutput> : IProtoOutput<TOutput>
	{
		MeasureState<T> Measure<T>(T value, object userState = null);

		void Serialize<T>(MeasureState<T> measured, TOutput destination);
	}
	internal interface ISerializationContext
	{
		TypeModel Model { get; }

		object UserState { get; }
	}
	internal struct MeasureState<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T> : IDisposable
	{
		private readonly TypeModel _model;

		private readonly T _value;

		private readonly object _userState;

		private ProtoWriter _writer;

		public long Length { get; }

		internal MeasureState(TypeModel model, in T value, object userState, long abortAfter)
		{
			_model = model;
			_value = value;
			_userState = userState;
			ProtoWriter.State state = ProtoWriter.NullProtoWriter.CreateNullProtoWriter(_model, userState, abortAfter);
			try
			{
				Length = TypeModel.SerializeImpl(ref state, _value);
				ProtoWriter.NullProtoWriter.CheckOversized(abortAfter, Length);
				_writer = state.GetWriter();
			}
			catch
			{
				state.Dispose();
				throw;
			}
		}

		public void Dispose()
		{
			ProtoWriter writer = _writer;
			_writer = null;
			writer?.Dispose();
		}

		public long LengthOnly()
		{
			long length = Length;
			Dispose();
			return length;
		}

		private void SerializeCore(ProtoWriter.State state)
		{
			try
			{
				ProtoWriter writer = _writer;
				if (writer == null)
				{
					throw new ObjectDisposedException("MeasureState");
				}
				ProtoWriter writer2 = state.GetWriter();
				writer2.InitializeFrom(writer);
				long num = TypeModel.SerializeImpl(ref state, _value);
				writer2.CopyBack(writer);
				if (num != Length)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Invalid length; expected {Length}, actual: {num}");
				}
			}
			catch (Exception ex)
			{
				ex.Data?.Add("ProtoBuf.MeasuredLength", Length);
				throw;
			}
			finally
			{
				state.Dispose();
			}
		}

		internal int GetLengthHits(out int misses)
		{
			return _writer.GetLengthHits(out misses);
		}

		public void Serialize(Stream stream)
		{
			SerializeCore(ProtoWriter.State.Create(stream, _model, _userState));
		}

		public void Serialize(IBufferWriter<byte> writer)
		{
			SerializeCore(ProtoWriter.State.Create(writer, _model, _userState));
		}
	}
	internal sealed class NetObjectCache
	{
		[StructLayout(LayoutKind.Auto)]
		private readonly struct ObjectKey : IEquatable<ObjectKey>
		{
			private readonly object _obj;

			private readonly Type _subTypeLevel;

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public ObjectKey(object obj, Type subTypeLevel)
			{
				_obj = obj;
				_subTypeLevel = subTypeLevel;
			}

			public override string ToString()
			{
				return $"{_subTypeLevel}/{_obj}";
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public override int GetHashCode()
			{
				return RuntimeHelpers.GetHashCode(_obj) ^ (_subTypeLevel?.GetHashCode() ?? 0);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public override bool Equals(object obj)
			{
				if (obj is ObjectKey other)
				{
					return Equals(other);
				}
				return false;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool Equals(ObjectKey other)
			{
				return (_obj == other._obj) & (_subTypeLevel == other._subTypeLevel);
			}
		}

		private readonly Dictionary<ObjectKey, long> _knownLengths = new Dictionary<ObjectKey, long>();

		private int _hit;

		private int _miss;

		internal int LengthHits => _hit;

		internal int LengthMisses => _miss;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryGetKnownLength(object obj, Type subTypeLevel, out long length)
		{
			if (_knownLengths.TryGetValue(new ObjectKey(obj, subTypeLevel), out length))
			{
				_hit++;
				return true;
			}
			_miss++;
			length = 0L;
			return false;
		}

		public void SetKnownLength(object obj, Type subTypeLevel, long length)
		{
			ObjectKey key = new ObjectKey(obj, subTypeLevel);
			_knownLengths[key] = length;
		}

		internal void Clear()
		{
			_knownLengths.Clear();
			_hit = (_miss = 0);
		}

		internal void InitializeFrom(NetObjectCache obj)
		{
			if (obj == null)
			{
				return;
			}
			_knownLengths.Clear();
			foreach (KeyValuePair<ObjectKey, long> knownLength in obj._knownLengths)
			{
				_knownLengths.Add(knownLength.Key, knownLength.Value);
			}
		}

		internal void CopyBack(NetObjectCache obj)
		{
			if (obj != null)
			{
				obj._hit += _hit;
				obj._miss += _miss;
			}
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class NullWrappedValueAttribute : Attribute
	{
		public bool AsGroup { get; set; }
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class NullWrappedCollectionAttribute : Attribute
	{
		public bool AsGroup { get; set; }
	}
	internal enum PrefixStyle
	{
		None,
		Base128,
		Fixed32,
		Fixed32BigEndian
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Interface, AllowMultiple = false, Inherited = false)]
	internal sealed class ProtoContractAttribute : Attribute
	{
		[Flags]
		private enum TypeOptions : ushort
		{
			InferTagFromName = 1,
			InferTagFromNameHasValue = 2,
			UseProtoMembersOnly = 4,
			SkipConstructor = 8,
			IgnoreListHandling = 0x10,
			IsGroup = 0x100,
			IgnoreUnknownSubTypes = 0x200
		}

		internal const string ReferenceDynamicDisabled = "Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited";

		private int implicitFirstTag;

		private TypeOptions flags;

		public string Name { get; set; }

		public string Origin { get; set; }

		public int ImplicitFirstTag
		{
			get
			{
				return implicitFirstTag;
			}
			set
			{
				if (value < 1)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("ImplicitFirstTag");
				}
				implicitFirstTag = value;
			}
		}

		public bool UseProtoMembersOnly
		{
			get
			{
				return HasFlag(TypeOptions.UseProtoMembersOnly);
			}
			set
			{
				SetFlag(TypeOptions.UseProtoMembersOnly, value);
			}
		}

		public bool IgnoreListHandling
		{
			get
			{
				return HasFlag(TypeOptions.IgnoreListHandling);
			}
			set
			{
				SetFlag(TypeOptions.IgnoreListHandling, value);
			}
		}

		public ImplicitFields ImplicitFields { get; set; }

		public bool InferTagFromName
		{
			get
			{
				return HasFlag(TypeOptions.InferTagFromName);
			}
			set
			{
				SetFlag(TypeOptions.InferTagFromName, value);
				SetFlag(TypeOptions.InferTagFromNameHasValue, value: true);
			}
		}

		internal bool InferTagFromNameHasValue => HasFlag(TypeOptions.InferTagFromNameHasValue);

		public int DataMemberOffset { get; set; }

		public bool SkipConstructor
		{
			get
			{
				return HasFlag(TypeOptions.SkipConstructor);
			}
			set
			{
				SetFlag(TypeOptions.SkipConstructor, value);
			}
		}

		public bool AsReferenceDefault
		{
			get
			{
				return false;
			}
			[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", true)]
			set
			{
				if (value != AsReferenceDefault)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
				}
			}
		}

		public bool IsGroup
		{
			get
			{
				return HasFlag(TypeOptions.IsGroup);
			}
			set
			{
				SetFlag(TypeOptions.IsGroup, value);
			}
		}

		public bool IgnoreUnknownSubTypes
		{
			get
			{
				return HasFlag(TypeOptions.IgnoreUnknownSubTypes);
			}
			set
			{
				SetFlag(TypeOptions.IgnoreUnknownSubTypes, value);
			}
		}

		[Obsolete("Enum value maps have been deprecated and are no longer supported; all enums are now effectively pass-thru; custom maps should be applied via shadow properties; in C#, lambda-based 'switch expressions' make for very convenient shadow properties", true)]
		public bool EnumPassthru
		{
			get
			{
				return true;
			}
			set
			{
				if (!value)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("EnumPassthru is not longer supported, and is always considered true");
				}
			}
		}

		public Type Surrogate { get; set; }

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicMethods)]
		public Type Serializer { get; set; }

		private bool HasFlag(TypeOptions flag)
		{
			return (flags & flag) == flag;
		}

		private void SetFlag(TypeOptions flag, bool value)
		{
			if (value)
			{
				flags |= flag;
			}
			else
			{
				flags &= (TypeOptions)(ushort)(~(int)flag);
			}
		}
	}
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)]
	internal class ProtoConverterAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Field, AllowMultiple = false)]
	internal sealed class ProtoEnumAttribute : Attribute
	{
		internal const string EnumValueDeprecated = "Enum value maps have been deprecated and are no longer supported; all enums are now effectively pass-thru; custom maps should be applied via shadow properties; in C#, lambda-based 'switch expressions' make for very convenient shadow properties";

		public int Value
		{
			[Obsolete("Enum value maps have been deprecated and are no longer supported; all enums are now effectively pass-thru; custom maps should be applied via shadow properties; in C#, lambda-based 'switch expressions' make for very convenient shadow properties", false)]
			get
			{
				return 0;
			}
			[Obsolete("Enum value maps have been deprecated and are no longer supported; all enums are now effectively pass-thru; custom maps should be applied via shadow properties; in C#, lambda-based 'switch expressions' make for very convenient shadow properties", true)]
			set
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			}
		}

		public string Name { get; set; }

		[Obsolete("Enum value maps have been deprecated and are no longer supported; all enums are now effectively pass-thru; custom maps should be applied via shadow properties; in C#, lambda-based 'switch expressions' make for very convenient shadow properties", false)]
		public bool HasValue()
		{
			return false;
		}
	}
	[Serializable]
	internal class ProtoException : Exception
	{
		public ProtoException()
		{
		}

		public ProtoException(string message)
			: base(message)
		{
		}

		public ProtoException(string message, Exception innerException)
			: base(message, innerException)
		{
		}

		protected ProtoException(SerializationInfo info, StreamingContext context)
			: base(info, context)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
	internal class ProtoIgnoreAttribute : Attribute
	{
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal sealed class ProtoPartialIgnoreAttribute : ProtoIgnoreAttribute
	{
		public string MemberName { get; }

		public ProtoPartialIgnoreAttribute(string memberName)
		{
			if (string.IsNullOrEmpty(memberName))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("memberName");
			}
			MemberName = memberName;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	internal sealed class ProtoIncludeAttribute : Attribute
	{
		public int Tag { get; }

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public string KnownTypeName { get; }

		[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)]
		public Type KnownType => TypeModel.ResolveKnownType(KnownTypeName, null);

		[DefaultValue(DataFormat.Default)]
		public DataFormat DataFormat { get; set; }

		public ProtoIncludeAttribute(int tag, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type knownType)
			: this(tag, ((object)knownType == null) ? "" : knownType.AssemblyQualifiedName)
		{
		}

		public ProtoIncludeAttribute(int tag, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] string knownTypeName)
		{
			if (tag <= 0)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("tag", "Tags must be positive integers");
			}
			if (string.IsNullOrEmpty(knownTypeName))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("knownTypeName", "Known type cannot be blank");
			}
			Tag = tag;
			KnownTypeName = knownTypeName;
		}
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field)]
	internal class ProtoMapAttribute : Attribute
	{
		public DataFormat KeyFormat { get; set; }

		public DataFormat ValueFormat { get; set; }

		public bool DisableMap { get; set; }
	}
	[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
	internal class ProtoMemberAttribute : Attribute, IComparable, IComparable<ProtoMemberAttribute>
	{
		internal MemberInfo Member;

		internal MemberInfo BackingMember;

		internal bool TagIsPinned;

		private string name;

		private DataFormat dataFormat;

		private int tag;

		private MemberSerializationOptions options;

		public string Name
		{
			get
			{
				return name;
			}
			set
			{
				name = value;
			}
		}

		public DataFormat DataFormat
		{
			get
			{
				return dataFormat;
			}
			set
			{
				dataFormat = value;
			}
		}

		public int Tag => tag;

		public bool IsRequired
		{
			get
			{
				return (options & MemberSerializationOptions.Required) == MemberSerializationOptions.Required;
			}
			set
			{
				if (value)
				{
					options |= MemberSerializationOptions.Required;
				}
				else
				{
					options &= ~MemberSerializationOptions.Required;
				}
			}
		}

		public bool IsPacked
		{
			get
			{
				return (options & MemberSerializationOptions.Packed) == MemberSerializationOptions.Packed;
			}
			set
			{
				if (value)
				{
					options |= MemberSerializationOptions.Packed;
				}
				else
				{
					options &= ~MemberSerializationOptions.Packed;
				}
			}
		}

		public bool OverwriteList
		{
			get
			{
				return (options & MemberSerializationOptions.OverwriteList) == MemberSerializationOptions.OverwriteList;
			}
			set
			{
				if (value)
				{
					options |= MemberSerializationOptions.OverwriteList;
				}
				else
				{
					options &= ~MemberSerializationOptions.OverwriteList;
				}
			}
		}

		[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", true)]
		public bool AsReference
		{
			get
			{
				return (options & MemberSerializationOptions.AsReference) == MemberSerializationOptions.AsReference;
			}
			set
			{
				if (value)
				{
					options |= MemberSerializationOptions.AsReference;
				}
				else
				{
					options &= ~MemberSerializationOptions.AsReference;
				}
				options |= MemberSerializationOptions.AsReferenceHasValue;
			}
		}

		[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", true)]
		internal bool AsReferenceHasValue
		{
			get
			{
				return (options & MemberSerializationOptions.AsReferenceHasValue) == MemberSerializationOptions.AsReferenceHasValue;
			}
			set
			{
				if (value)
				{
					options |= MemberSerializationOptions.AsReferenceHasValue;
				}
				else
				{
					options &= ~MemberSerializationOptions.AsReferenceHasValue;
				}
			}
		}

		[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", true)]
		public bool DynamicType
		{
			get
			{
				return (options & MemberSerializationOptions.DynamicType) == MemberSerializationOptions.DynamicType;
			}
			set
			{
				if (value)
				{
					options |= MemberSerializationOptions.DynamicType;
				}
				else
				{
					options &= ~MemberSerializationOptions.DynamicType;
				}
			}
		}

		public MemberSerializationOptions Options
		{
			get
			{
				return options;
			}
			set
			{
				options = value;
			}
		}

		public int CompareTo(object other)
		{
			return CompareTo(other as ProtoMemberAttribute);
		}

		public int CompareTo(ProtoMemberAttribute other)
		{
			if (other == null)
			{
				return -1;
			}
			if (this == other)
			{
				return 0;
			}
			int num = tag.CompareTo(other.tag);
			if (num == 0)
			{
				num = string.CompareOrdinal(name, other.name);
			}
			return num;
		}

		public ProtoMemberAttribute(int tag)
			: this(tag, forced: false)
		{
		}

		internal ProtoMemberAttribute(int tag, bool forced)
		{
			if (tag <= 0 && !forced)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("tag");
			}
			this.tag = tag;
		}

		internal void Rebase(int tag)
		{
			this.tag = tag;
		}
	}
	[Flags]
	internal enum MemberSerializationOptions
	{
		None = 0,
		Packed = 1,
		Required = 2,
		[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", false)]
		AsReference = 4,
		[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", false)]
		DynamicType = 8,
		OverwriteList = 0x10,
		[Obsolete("Reference-tracking and dynamic-type are not currently implemented in this build; they may be reinstated later; this is partly due to doubts over whether the features are adviseable, and partly over confidence in testing all the scenarios (it takes time; that time hasn't get happened); feedback is invited", false)]
		AsReferenceHasValue = 0x20
	}
	[AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = false)]
	internal sealed class ProtoPartialMemberAttribute : ProtoMemberAttribute
	{
		public string MemberName { get; private set; }

		public ProtoPartialMemberAttribute(int tag, string memberName)
			: base(tag)
		{
			if (string.IsNullOrEmpty(memberName))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("memberName");
			}
			MemberName = memberName;
		}
	}
	internal abstract class ProtoReader : IDisposable, ISerializationContext
	{
		private protected enum Read32VarintMode
		{
			Signed,
			Unsigned,
			FieldHeader
		}

		[StructLayout(LayoutKind.Auto)]
		public ref struct State
		{
			private ProtoReader _reader;

			private ReadOnlyMemory<byte> _memory;

			internal ReadOnlySpan<byte> Span { get; private set; }

			internal int OffsetInCurrent { get; private set; }

			internal int RemainingInCurrent { get; private set; }

			public WireType WireType
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return _reader.WireType;
				}
			}

			public bool InternStrings
			{
				get
				{
					return _reader.InternStrings;
				}
				set
				{
					_reader.InternStrings = value;
				}
			}

			public int FieldNumber
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return _reader._fieldNumber;
				}
			}

			internal TypeModel Model
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return _reader?.Model;
				}
				private set
				{
					_reader.Model = value;
				}
			}

			public ISerializationContext Context
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return _reader;
				}
			}

			public static State Create(ReadOnlySequence<byte> source, TypeModel model, object userState = null)
			{
				ReadOnlySequenceProtoReader readOnlySequenceProtoReader = Pool<ReadOnlySequenceProtoReader>.TryGet() ?? new ReadOnlySequenceProtoReader();
				readOnlySequenceProtoReader.Init(source, model, userState);
				return new State(readOnlySequenceProtoReader);
			}

			public static State Create(ReadOnlyMemory<byte> source, TypeModel model, object userState = null)
			{
				return Create(new ReadOnlySequence<byte>(source), model, userState);
			}

			public void Dispose()
			{
				ProtoReader reader = _reader;
				this = default(State);
				reader?.Dispose();
			}

			internal SolidState Solidify()
			{
				return new SolidState(_reader, _memory.Slice(OffsetInCurrent, RemainingInCurrent));
			}

			internal State(ProtoReader reader, ReadOnlyMemory<byte> memory)
				: this(reader)
			{
				Init(memory);
			}

			internal State(ProtoReader reader)
			{
				this = default(State);
				_reader = reader;
			}

			internal void Init(ReadOnlyMemory<byte> memory)
			{
				_memory = memory;
				Span = memory.Span;
				OffsetInCurrent = 0;
				RemainingInCurrent = Span.Length;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void Skip(int bytes)
			{
				OffsetInCurrent += bytes;
				RemainingInCurrent -= bytes;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal ReadOnlySpan<byte> Consume(int bytes)
			{
				ReadOnlySpan<byte> result = Span.Slice(OffsetInCurrent, bytes);
				OffsetInCurrent += bytes;
				RemainingInCurrent -= bytes;
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal ReadOnlySpan<byte> Consume(int bytes, out int offset)
			{
				offset = OffsetInCurrent;
				OffsetInCurrent += bytes;
				RemainingInCurrent -= bytes;
				return Span;
			}

			internal int ReadVarintUInt32(out uint value)
			{
				value = Span[OffsetInCurrent];
				int num = (((value & 0x80) == 0) ? 1 : ParseVarintUInt32Tail(Span.Slice(OffsetInCurrent), ref value));
				OffsetInCurrent += num;
				RemainingInCurrent -= num;
				return num;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal int ParseVarintUInt32(ReadOnlySpan<byte> span, out uint value)
			{
				value = span[0];
				if ((value & 0x80u) != 0)
				{
					return ParseVarintUInt32Tail(span, ref value);
				}
				return 1;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal int ParseVarintUInt32(ReadOnlySpan<byte> span, int offset, out uint value)
			{
				value = span[offset];
				if ((value & 0x80u) != 0)
				{
					return ParseVarintUInt32Tail(span.Slice(offset), ref value);
				}
				return 1;
			}

			private int ParseVarintUInt32Tail(ReadOnlySpan<byte> span, ref uint value)
			{
				uint num = span[1];
				value = (value & 0x7Fu) | ((num & 0x7F) << 7);
				if ((num & 0x80) == 0)
				{
					return 2;
				}
				num = span[2];
				value |= (num & 0x7F) << 14;
				if ((num & 0x80) == 0)
				{
					return 3;
				}
				num = span[3];
				value |= (num & 0x7F) << 21;
				if ((num & 0x80) == 0)
				{
					return 4;
				}
				num = span[4];
				value |= num << 28;
				if ((num & 0xF0) == 0)
				{
					return 5;
				}
				ThrowOverflow();
				return 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void Advance(long count)
			{
				_reader.Advance(count);
			}

			internal static int TryParseUInt64Varint(ReadOnlySpan<byte> span, int offset, out ulong value)
			{
				if ((uint)offset >= (uint)span.Length)
				{
					value = 0uL;
					return 0;
				}
				value = span[offset++];
				if ((value & 0x80) == 0L)
				{
					return 1;
				}
				value &= 127uL;
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				ulong num = span[offset++];
				value |= (num & 0x7F) << 7;
				if ((num & 0x80) == 0L)
				{
					return 2;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 14;
				if ((num & 0x80) == 0L)
				{
					return 3;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 21;
				if ((num & 0x80) == 0L)
				{
					return 4;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 28;
				if ((num & 0x80) == 0L)
				{
					return 5;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 35;
				if ((num & 0x80) == 0L)
				{
					return 6;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 42;
				if ((num & 0x80) == 0L)
				{
					return 7;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 49;
				if ((num & 0x80) == 0L)
				{
					return 8;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 56;
				if ((num & 0x80) == 0L)
				{
					return 9;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					NoContextThrowEoF();
				}
				num = span[offset];
				value |= num << 63;
				if ((num & 0xFFFFFFFFFFFFFFFEuL) != 0L)
				{
					NoContextThrowOverflow();
				}
				return 10;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal ProtoReader GetReader()
			{
				return _reader;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public ushort ReadUInt16()
			{
				return checked((ushort)ReadUInt32());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public short ReadInt16()
			{
				return checked((short)ReadInt32());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public long GetPosition()
			{
				return _reader._longPosition;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public byte ReadByte()
			{
				return checked((byte)ReadUInt32());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public sbyte ReadSByte()
			{
				return checked((sbyte)ReadInt32());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public IntPtr ReadIntPtr()
			{
				return new IntPtr(ReadInt64());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public UIntPtr ReadUIntPtr()
			{
				return new UIntPtr(ReadUInt64());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public uint ReadUInt32()
			{
				switch (_reader.WireType)
				{
				case WireType.Variant:
					return ReadUInt32Varint(Read32VarintMode.Signed);
				case WireType.Fixed32:
					return _reader.ImplReadUInt32Fixed(ref this);
				case WireType.Fixed64:
				{
					ulong num = _reader.ImplReadUInt64Fixed(ref this);
					return checked((uint)num);
				}
				default:
					ThrowWireTypeException();
					return 0u;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public int ReadInt32()
			{
				switch (_reader.WireType)
				{
				case WireType.Variant:
					return (int)ReadUInt32Varint(Read32VarintMode.Signed);
				case WireType.Fixed32:
					return (int)_reader.ImplReadUInt32Fixed(ref this);
				case WireType.Fixed64:
				{
					long num = ReadInt64();
					return checked((int)num);
				}
				case WireType.SignedVariant:
					return Zag(ReadUInt32Varint(Read32VarintMode.Signed));
				default:
					ThrowWireTypeException();
					return 0;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public long ReadInt64()
			{
				switch (_reader.WireType)
				{
				case WireType.Variant:
					return (long)ReadUInt64Varint();
				case WireType.Fixed32:
					return (int)_reader.ImplReadUInt32Fixed(ref this);
				case WireType.Fixed64:
					return (long)_reader.ImplReadUInt64Fixed(ref this);
				case WireType.SignedVariant:
					return Zag(ReadUInt64Varint());
				default:
					ThrowWireTypeException();
					return 0L;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public unsafe double ReadDouble()
			{
				switch (_reader.WireType)
				{
				case WireType.Fixed32:
					return ReadSingle();
				case WireType.Fixed64:
				{
					long num = ReadInt64();
					return *(double*)(&num);
				}
				default:
					ThrowWireTypeException();
					return 0.0;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public unsafe float ReadSingle()
			{
				switch (_reader.WireType)
				{
				case WireType.Fixed32:
				{
					int num3 = ReadInt32();
					return *(float*)(&num3);
				}
				case WireType.Fixed64:
				{
					double num = ReadDouble();
					float num2 = (float)num;
					if (float.IsInfinity(num2) && !double.IsInfinity(num))
					{
						ThrowOverflow();
					}
					return num2;
				}
				default:
					ThrowWireTypeException();
					return 0f;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void PrepareToReadRepeated<T>(ref SerializerFeatures features, SerializerFeatures serializerFeatures, out SerializerFeatures category, out bool packed)
			{
				if (serializerFeatures.IsRepeated())
				{
					TypeModel.ThrowNestedListsNotSupported(typeof(T));
				}
				features.InheritFrom(serializerFeatures);
				category = serializerFeatures.GetCategory();
				packed = false;
				if (TypeHelper<T>.CanBePacked && WireType == WireType.String && !features.HasAny(SerializerFeatures.OptionWrappedValue))
				{
					if (category != SerializerFeatures.CategoryScalar)
					{
						ThrowInvalidOperationException("Packed data expected a scalar serializer");
					}
					packed = true;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void ReadRepeatedCore<TSerializer, TList, T>(ref TList values, SerializerFeatures category, WireType wireType, in TSerializer serializer, SerializerFeatures features) where TSerializer : ISerializer<T> where TList : ICollection<T>
			{
				int fieldNumber = FieldNumber;
				bool flag = features.HasAny(SerializerFeatures.OptionWrappedValue);
				T value = features.DefaultFor<T>();
				do
				{
					T item;
					if (flag)
					{
						item = ReadWrapped(features, value, serializer);
					}
					else
					{
						switch (category)
						{
						case SerializerFeatures.CategoryScalar:
							Hint(wireType);
							item = serializer.Read(ref this, value);
							break;
						case SerializerFeatures.CategoryMessage:
						case SerializerFeatures.CategoryMessageWrappedAtRoot:
							item = ReadMessage(SerializerFeatures.CategoryRepeated, value, in serializer);
							break;
						default:
							category.ThrowInvalidCategory();
							item = default(T);
							break;
						}
					}
					values.Add(item);
				}
				while (TryReadFieldHeader(fieldNumber));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void ReadPackedScalar<TSerializer, TList, T>(ref TList list, WireType wireType, in TSerializer serializer) where TSerializer : ISerializer<T> where TList : ICollection<T>
			{
				int num = (int)ReadUInt32Varint(Read32VarintMode.Unsigned);
				if (num == 0)
				{
					return;
				}
				if (num < 0)
				{
					ThrowInvalidLength(num);
				}
				int num2;
				if (wireType <= WireType.Fixed64)
				{
					if (wireType == WireType.Variant)
					{
						goto IL_00ff;
					}
					if (wireType == WireType.Fixed64)
					{
						if (num % 8 != 0)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("packed length should be multiple of 8");
						}
						num2 = num / 8;
						goto IL_0065;
					}
				}
				else
				{
					if (wireType == WireType.Fixed32)
					{
						if (num % 4 != 0)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("packed length should be multiple of 4");
						}
						num2 = num / 4;
						goto IL_0065;
					}
					if (wireType == WireType.SignedVariant)
					{
						goto IL_00ff;
					}
				}
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidPackedOperationException(WireType, typeof(T));
				return;
				IL_00ff:
				long num3 = GetPosition() + num;
				TList val;
				TSerializer val2;
				do
				{
					_reader.WireType = wireType;
					ref TList reference = ref list;
					val = default(TList);
					if (val == null)
					{
						val = reference;
						reference = ref val;
					}
					val2 = serializer;
					reference.Add(val2.Read(ref this, default(T)));
				}
				while (GetPosition() < num3);
				if (GetPosition() != num3)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("over-read packed data");
				}
				return;
				IL_0065:
				if ((object)list is List<T> list2)
				{
					list2.Capacity = Math.Max(list2.Capacity, list2.Count + Math.Min(num2, 8192));
				}
				for (int i = 0; i < num2; i++)
				{
					_reader.WireType = wireType;
					ref TList reference2 = ref list;
					val = default(TList);
					if (val == null)
					{
						val = reference2;
						reference2 = ref val;
					}
					val2 = serializer;
					reference2.Add(val2.Read(ref this, default(T)));
				}
			}

			internal ReadBuffer<T> FillBuffer<TSerializer, T>(SerializerFeatures features, in TSerializer serializer, T initialValue) where TSerializer : ISerializer<T>
			{
				PrepareToReadRepeated<T>(ref features, serializer.Features, out var category, out var packed);
				ReadBuffer<T> list = ReadBuffer<T>.Create();
				try
				{
					WireType wireType = features.GetWireType();
					if (packed)
					{
						ReadPackedScalar<TSerializer, ReadBuffer<T>, T>(ref list, wireType, in serializer);
					}
					else
					{
						ReadRepeatedCore<TSerializer, ReadBuffer<T>, T>(ref list, category, wireType, in serializer, features);
					}
					return list;
				}
				catch
				{
					try
					{
						list.Dispose();
					}
					catch
					{
					}
					throw;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool ReadBoolean()
			{
				return ReadUInt32() != 0;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public ulong ReadUInt64()
			{
				switch (_reader.WireType)
				{
				case WireType.Variant:
					return ReadUInt64Varint();
				case WireType.Fixed32:
					return _reader.ImplReadUInt32Fixed(ref this);
				case WireType.Fixed64:
					return _reader.ImplReadUInt64Fixed(ref this);
				default:
					ThrowWireTypeException();
					return 0uL;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public byte[] AppendBytes(byte[] value)
			{
				return AppendBytesImpl(value, DefaultMemoryConverter<byte>.Instance);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public ReadOnlyMemory<byte> AppendBytes(ReadOnlyMemory<byte> value)
			{
				return AppendBytesImpl(value, DefaultMemoryConverter<byte>.Instance);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Memory<byte> AppendBytes(Memory<byte> value)
			{
				return AppendBytesImpl(value, DefaultMemoryConverter<byte>.Instance);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public ArraySegment<byte> AppendBytes(ArraySegment<byte> value)
			{
				return AppendBytesImpl(value, DefaultMemoryConverter<byte>.Instance);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public TStorage AppendBytes<TStorage>(TStorage value, IMemoryConverter<TStorage, byte> converter = null)
			{
				return AppendBytesImpl(value, converter ?? DefaultMemoryConverter<byte>.GetFor<TStorage>(Model));
			}

			private TStorage AppendBytesImpl<TStorage>(TStorage value, IMemoryConverter<TStorage, byte> converter)
			{
				WireType wireType = _reader.WireType;
				if (wireType == WireType.String)
				{
					int num = (int)ReadUInt32Varint(Read32VarintMode.Signed);
					_reader.WireType = WireType.None;
					if (num == 0)
					{
						return converter.NonNull(in value);
					}
					if (num < 0)
					{
						ThrowInvalidLength(num);
					}
					Memory<byte> memory = converter.Expand(Context, ref value, num);
					_reader.ImplReadBytes(ref this, memory.Span);
					return value;
				}
				ThrowWireTypeException();
				return default(TStorage);
			}

			[Browsable(false)]
			public Span<byte> ReadBytes(Span<byte> destination)
			{
				ReadBytes(destination, out var length);
				return destination.Slice(0, length);
			}

			public void ReadBytes(Span<byte> destination, out int length)
			{
				WireType wireType = _reader.WireType;
				if (wireType == WireType.String)
				{
					length = (int)ReadUInt32Varint(Read32VarintMode.Signed);
					if (length < 0)
					{
						ThrowInvalidLength(length);
					}
					if (length > destination.Length)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Insufficient space in the target span to read a string/bytes value; {destination.Length} vs {length} bytes");
					}
					_reader.WireType = WireType.None;
					destination = destination.Slice(0, length);
					_reader.ImplReadBytes(ref this, destination);
				}
				else
				{
					length = 0;
					ThrowWireTypeException();
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public SubItemToken StartSubItem()
			{
				ProtoReader reader = _reader;
				switch (_reader.WireType)
				{
				case WireType.StartGroup:
					reader.WireType = WireType.None;
					if (reader.IncrDepth())
					{
						ThrowTooDeep();
					}
					return new SubItemToken(-reader._fieldNumber);
				case WireType.String:
				{
					long num = (long)ReadUInt64Varint();
					if (num < 0)
					{
						ThrowInvalidOperationException();
					}
					long blockEnd = reader.blockEnd64;
					reader.blockEnd64 = reader._longPosition + num;
					if (reader.IncrDepth())
					{
						ThrowTooDeep();
					}
					return new SubItemToken(blockEnd);
				}
				default:
					ThrowWireTypeException();
					return default(SubItemToken);
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public void EndSubItem(SubItemToken token)
			{
				long value = token.value64;
				ProtoReader reader = _reader;
				WireType wireType = reader.WireType;
				if (wireType == WireType.EndGroup)
				{
					if (value >= 0)
					{
						ThrowProtoException("A length-based message was terminated via end-group; this indicates data corruption");
					}
					if (-(int)value != reader._fieldNumber)
					{
						ThrowProtoException("Wrong group was ended");
					}
					reader.WireType = WireType.None;
					reader.DecrDepth();
					return;
				}
				long longPosition = reader._longPosition;
				if (value < longPosition)
				{
					ThrowProtoException($"Sub-message not read entirely; expected {value}, was {longPosition}");
				}
				if (reader.blockEnd64 != longPosition && reader.blockEnd64 != long.MaxValue)
				{
					ThrowProtoException($"Sub-message not read correctly (end {reader.blockEnd64} vs {longPosition})");
				}
				reader.blockEnd64 = value;
				reader.DecrDepth();
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal object ReadObject(object value, Type type)
			{
				return ReadTypedObject(value, type);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal object ReadTypedObject(object value, Type type)
			{
				TypeModel model = Model;
				if (model == null)
				{
					ThrowInvalidOperationException("Cannot deserialize sub-objects unless a model is provided");
				}
				if (DynamicStub.TryDeserialize(ObjectScope.WrappedMessage, type, model, ref this, ref value))
				{
					return value;
				}
				SubItemToken token = StartSubItem();
				if ((object)type == null || !model.TryDeserializeAuxiliaryType(ref this, DataFormat.Default, 1, type, ref value, skipOtherFields: true, asListItem: false, autoCreate: true, insideList: false, null, isRoot: false))
				{
					TypeModel.ThrowUnexpectedType(type, Model);
				}
				EndSubItem(token);
				return value;
			}

			internal void SkipAllFields()
			{
				while (ReadFieldHeader() > 0)
				{
					SkipField();
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public string ReadString(StringMap map = null)
			{
				if (_reader.WireType == WireType.String)
				{
					int num = (int)ReadUInt32Varint(Read32VarintMode.Unsigned);
					if (num == 0)
					{
						return "";
					}
					if (num < 0)
					{
						ThrowInvalidLength(num);
					}
					string text = _reader.ImplReadString(ref this, num);
					if (_reader.InternStrings)
					{
						text = _reader.Intern(text);
					}
					return text;
				}
				ThrowWireTypeException();
				return null;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private uint ReadUInt32Varint(Read32VarintMode mode)
			{
				uint value;
				int num = _reader.ImplTryReadUInt32VarintWithoutMoving(ref this, mode, out value);
				if (num <= 0)
				{
					if (mode == Read32VarintMode.FieldHeader)
					{
						return 0u;
					}
					ThrowEoF();
				}
				_reader.ImplSkipBytes(ref this, num);
				return value;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private ulong ReadUInt64Varint()
			{
				ulong value;
				int num = _reader.ImplTryReadUInt64VarintWithoutMoving(ref this, out value);
				if (num <= 0)
				{
					ThrowEoF();
				}
				_reader.ImplSkipBytes(ref this, num);
				return value;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Assert(WireType wireType)
			{
				WireType wireType2 = _reader.WireType;
				if (wireType2 != wireType)
				{
					if ((wireType & (WireType)7) == wireType2)
					{
						_reader.WireType = wireType;
					}
					else
					{
						ThrowWireTypeException();
					}
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void SkipField()
			{
				switch (_reader.WireType)
				{
				case WireType.Fixed32:
					_reader.ImplSkipBytes(ref this, 4L);
					break;
				case WireType.Fixed64:
					_reader.ImplSkipBytes(ref this, 8L);
					break;
				case WireType.String:
				{
					long num = (long)ReadUInt64Varint();
					if (num < 0)
					{
						ThrowInvalidLength(num);
					}
					_reader.ImplSkipBytes(ref this, num);
					break;
				}
				case WireType.Variant:
				case WireType.SignedVariant:
					ReadUInt64Varint();
					break;
				case WireType.StartGroup:
					SkipGroup();
					break;
				default:
					ThrowWireTypeException();
					break;
				}
			}

			internal Type DeserializeType(string typeName)
			{
				return _reader.DeserializeType(typeName);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private void SkipGroup()
			{
				int fieldNumber = _reader._fieldNumber;
				if (_reader.IncrDepth())
				{
					ThrowTooDeep();
				}
				while (ReadFieldHeader() > 0)
				{
					SkipField();
				}
				_reader.DecrDepth();
				if (_reader.WireType == WireType.EndGroup && _reader._fieldNumber == fieldNumber)
				{
					_reader.WireType = WireType.None;
				}
				else
				{
					ThrowWireTypeException();
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public int ReadFieldHeader()
			{
				if (_reader.blockEnd64 <= _reader._longPosition || _reader.WireType == WireType.EndGroup)
				{
					return 0;
				}
				if (RemainingInCurrent >= 5)
				{
					uint value;
					int num = ReadVarintUInt32(out value);
					_reader.Advance(num);
					return _reader.SetTag(value);
				}
				return ReadFieldHeaderFallback();
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private int ReadFieldHeaderFallback()
			{
				uint value;
				int num = _reader.ImplTryReadUInt32VarintWithoutMoving(ref this, Read32VarintMode.FieldHeader, out value);
				if (num == 0)
				{
					_reader.WireType = WireType.Variant;
					return _reader._fieldNumber = 0;
				}
				_reader.ImplSkipBytes(ref this, num);
				return _reader.SetTag(value);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool TryReadFieldHeader(int field)
			{
				ProtoReader reader = _reader;
				if (reader.blockEnd64 <= reader._longPosition || reader.WireType == WireType.EndGroup)
				{
					return false;
				}
				uint value;
				int num = reader.ImplTryReadUInt32VarintWithoutMoving(ref this, Read32VarintMode.FieldHeader, out value);
				WireType wireType;
				if (num > 0 && (int)value >> 3 == field && (wireType = (WireType)((int)value & 7)) != WireType.EndGroup)
				{
					reader.WireType = wireType;
					reader._fieldNumber = field;
					reader.ImplSkipBytes(ref this, num);
					return true;
				}
				return false;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void CheckFullyConsumed()
			{
				if (!_reader.IsFullyConsumed(ref this))
				{
					ThrowProtoException("Incorrect number of bytes consumed");
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Hint(WireType wireType)
			{
				_reader.Hint(wireType);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowWireTypeException()
			{
				string message = ((_reader == null) ? "(no reader)" : $"Invalid wire-type ({_reader.WireType}); this usually means you have over-written a file without truncating or setting the length; see https://stackoverflow.com/q/2152978/23354");
				ThrowProtoException(message);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowProtoException(string message)
			{
				throw AddErrorData(new ProtoException(message), _reader, ref this);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowEoF()
			{
				throw AddErrorData(new EndOfStreamException(), _reader, ref this);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowTooDeep()
			{
				ThrowInvalidOperationException("Maximum model depth exceeded (see TypeModel.MaxDepth): " + _reader._depth);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowInvalidOperationException(string message = null)
			{
				InvalidOperationException exception = (string.IsNullOrWhiteSpace(message) ? new InvalidOperationException() : new InvalidOperationException(message));
				throw AddErrorData(exception, _reader, ref this);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowInvalidLength(long length)
			{
				ThrowInvalidOperationException("Invalid length: " + length);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowArgumentException(string message)
			{
				throw AddErrorData(new ArgumentException(message), _reader, ref this);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowOverflow()
			{
				throw AddErrorData(new OverflowException(), _reader, ref this);
			}

			internal static Exception AddErrorData(Exception exception, ProtoReader source, ref State state)
			{
				if (exception != null && source != null && !exception.Data.Contains("protoSource"))
				{
					exception.Data.Add("protoSource", $"tag={source.FieldNumber}; wire-type={source.WireType}; offset={state.GetPosition()}; depth={source._depth}");
				}
				return exception;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static int Zag(uint ziggedValue)
			{
				return (int)(0 - (ziggedValue & 1)) ^ (((int)ziggedValue >> 1) & 0x7FFFFFFF);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static long Zag(ulong ziggedValue)
			{
				return (long)(0L - (ziggedValue & 1)) ^ (((long)ziggedValue >> 1) & 0x7FFFFFFFFFFFFFFFL);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public void ThrowEnumException(Type type, int value)
			{
				string text = (((object)type == null) ? "<null>" : type.FullName);
				throw AddErrorData(new ProtoException("No " + text + " enum is mapped to the wire-value " + value), _reader, ref this);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public void AppendExtensionData(IExtensible instance)
			{
				if (instance == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("instance");
				}
				AppendExtensionDataImpl(instance.GetExtensionObject(createIfMissing: true));
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public void AppendExtensionData(ITypedExtensible instance, Type type)
			{
				if (instance == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("instance");
				}
				AppendExtensionDataImpl(instance.GetExtensionObject(type, createIfMissing: true));
			}

			private void AppendExtensionDataImpl(IExtension extn)
			{
				bool commit = false;
				Stream stream = extn.BeginAppend();
				try
				{
					ProtoWriter.State writeState = ProtoWriter.State.Create(stream, _reader._model);
					try
					{
						AppendExtensionField(ref writeState);
						writeState.Close();
					}
					catch
					{
						writeState.Abandon();
						throw;
					}
					finally
					{
						writeState.Dispose();
					}
					commit = true;
				}
				finally
				{
					extn.EndAppend(stream, commit);
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private void AppendExtensionField(ref ProtoWriter.State writeState)
			{
				ProtoReader reader = _reader;
				writeState.WriteFieldHeader(reader._fieldNumber, reader.WireType);
				switch (reader.WireType)
				{
				case WireType.Fixed32:
					writeState.WriteInt32(ReadInt32());
					break;
				case WireType.Variant:
				case WireType.Fixed64:
				case WireType.SignedVariant:
					writeState.WriteInt64(ReadInt64());
					break;
				case WireType.String:
					writeState.WriteBytes(AppendBytes(null));
					break;
				case WireType.StartGroup:
				{
					SubItemToken token = StartSubItem();
					SubItemToken token2 = writeState.StartSubItem(null);
					while (ReadFieldHeader() > 0)
					{
						AppendExtensionField(ref writeState);
					}
					EndSubItem(token);
					writeState.EndSubItem(token2);
					break;
				}
				default:
					ThrowWireTypeException();
					break;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public Type ReadType()
			{
				return TypeModel.DeserializeType(_reader._model, ReadString());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public T ReadMessage<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value = default(T))
			{
				return ReadMessage(SerializerFeatures.CategoryRepeated, value);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public T ReadMessage<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializerFeatures features, T value = default(T), ISerializer<T> serializer = null)
			{
				ISerializer<T> serializer2 = serializer ?? TypeModel.GetSerializer<T>(Model);
				return ReadMessage(features, value, in serializer2);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal T ReadMessage<TSerializer, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializerFeatures features, T value, in TSerializer serializer) where TSerializer : ISerializer<T>
			{
				SubItemToken token = StartSubItem();
				T result = serializer.Read(ref this, value);
				EndSubItem(token);
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public T ReadAny<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value = default(T))
			{
				return ReadAny(SerializerFeatures.CategoryRepeated, value);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public T ReadAny<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializerFeatures features, T value = default(T), ISerializer<T> serializer = null)
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSerializer<T>(Model);
				}
				SerializerFeatures features2 = serializer.Features;
				features.InheritFrom(features2);
				if (features.HasAny(SerializerFeatures.OptionWrappedValue | SerializerFeatures.OptionWrappedCollection))
				{
					return ReadWrapped(features, value, serializer);
				}
				switch (features2.GetCategory())
				{
				case SerializerFeatures.CategoryMessage:
				case SerializerFeatures.CategoryMessageWrappedAtRoot:
					return ReadMessage(features, value, serializer);
				case SerializerFeatures.CategoryRepeated:
					return ((IRepeatedSerializer<T>)serializer).ReadRepeated(ref this, features, value);
				case SerializerFeatures.CategoryScalar:
					features.HintIfNeeded(ref this);
					return serializer.Read(ref this, value);
				default:
					features.ThrowInvalidCategory();
					return default(T);
				}
			}

			public T ReadWrapped<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializerFeatures features, T value, ISerializer<T> serializer = null)
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSerializer<T>(Model);
				}
				features.InheritFrom(serializer.Features);
				ProtoWriter.State.AssertWrappedAndGetWireType(ref features, out var fieldPresence);
				SubItemToken token = StartSubItem();
				int num;
				while ((num = ReadFieldHeader()) > 0)
				{
					if (num == 1)
					{
						value = ReadAny(features, value, serializer);
					}
					else
					{
						SkipField();
					}
				}
				EndSubItem(token);
				if (!fieldPresence && TypeHelper<T>.CanBeNull && TypeHelper<T>.ValueChecker.IsNull(value))
				{
					value = TypeHelper<T>.NonTrivialDefault;
				}
				return value;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public ISerializer<T> GetSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
			{
				return TypeModel.GetSerializer<T>(Model);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public T ReadBaseType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TBaseType, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value = null, ISubTypeSerializer<TBaseType> serializer = null) where TBaseType : class where T : class, TBaseType
			{
				return (T)(serializer ?? TypeModel.GetSubTypeSerializer<TBaseType>(_reader._model)).ReadSubType(ref this, SubTypeState<TBaseType>.Create(_reader, value));
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public T DeserializeRoot<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value = default(T), ISerializer<T> serializer = null)
			{
				value = ReadAsRoot(value, serializer ?? TypeModel.GetSerializer<T>(Model));
				CheckFullyConsumed();
				return value;
			}

			internal T ReadAsRoot<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value, ISerializer<T> serializer)
			{
				SerializerFeatures features2 = serializer.Features;
				switch (features2.GetCategory())
				{
				case SerializerFeatures.CategoryMessageWrappedAtRoot:
					return ReadFieldOne(ref this, features2, value, serializer);
				case SerializerFeatures.CategoryMessage:
					return serializer.Read(ref this, value);
				case SerializerFeatures.CategoryRepeated:
				case SerializerFeatures.CategoryScalar:
					return ReadFieldOne(ref this, features2, value, serializer);
				default:
					features2.ThrowInvalidCategory();
					return default(T);
				}
				static T ReadFieldOne(ref State state, SerializerFeatures features, T value, ISerializer<T> serializer)
				{
					bool flag = false;
					int num;
					while ((num = state.ReadFieldHeader()) > 0)
					{
						if (num == 1)
						{
							flag = true;
							value = state.ReadAny(features, value, serializer);
						}
						else
						{
							state.SkipField();
						}
					}
					if (TypeHelper<T>.IsReferenceType && !flag && value == null)
					{
						value = state.CreateInstance(serializer);
					}
					return value;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public bool HasSubValue(WireType wireType)
			{
				return ProtoReader.HasSubValue(wireType, _reader);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			public T CreateInstance<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ISerializer<T> serializer = null)
			{
				return TypeModel.CreateInstance(Context, serializer);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal object DeserializeRootFallbackWithModel(object value, Type type, TypeModel overrideModel)
			{
				TypeModel model = Model;
				try
				{
					Model = overrideModel;
					return DeserializeRootFallback(value, type);
				}
				finally
				{
					Model = model;
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal object DeserializeRootFallback(object value, Type type)
			{
				bool autoCreate = TypeModel.PrepareDeserialize(value, ref type);
				object result = Model.DeserializeRootAny(ref this, type, value, autoCreate);
				CheckFullyConsumed();
				return result;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal T DeserializeRootImpl<T>(T value = default(T))
			{
				ISerializer<T> serializer = TypeModel.TryGetSerializer<T>(Model);
				if (serializer == null)
				{
					return (T)DeserializeRootFallback(value, typeof(T));
				}
				return DeserializeRoot(value, serializer);
			}

			public static State Create(Stream source, TypeModel model, object userState = null, long length = -1L)
			{
				ProtoReader reader = ProtoReader.Create(source, model, userState, length);
				return new State(reader);
			}
		}

		private sealed class ReadOnlySequenceProtoReader : ProtoReader
		{
			private ReadOnlySequence<byte>.Enumerator _source;

			protected internal override State DefaultState()
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("You must retain and pass the state from ProtoReader.Create");
				return default(State);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal unsafe static string ToString(ReadOnlySpan<byte> span, int offset, int bytes)
			{
				fixed (byte* ptr = &MemoryMarshal.GetReference(span))
				{
					byte* bytes2 = ptr + offset;
					int charCount = UTF8.GetCharCount(bytes2, bytes);
					string text = new string('\0', charCount);
					fixed (char* chars = text)
					{
						UTF8.GetChars(bytes2, bytes, chars, charCount);
					}
					return text;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal unsafe static string ToString(ReadOnlySpan<byte> span)
			{
				fixed (byte* ptr = &MemoryMarshal.GetReference(span))
				{
					byte* bytes = ptr;
					int length = span.Length;
					int charCount = UTF8.GetCharCount(bytes, length);
					string text = new string('\0', charCount);
					fixed (char* chars = text)
					{
						UTF8.GetChars(bytes, length, chars, charCount);
					}
					return text;
				}
			}

			internal static int TryParseUInt32Varint(ref State state, int offset, bool trimNegative, out uint value, ReadOnlySpan<byte> span)
			{
				if ((uint)offset >= (uint)span.Length)
				{
					value = 0u;
					return 0;
				}
				value = span[offset++];
				if ((value & 0x80) == 0)
				{
					return 1;
				}
				value &= 127u;
				if ((uint)offset >= (uint)span.Length)
				{
					state.ThrowEoF();
				}
				uint num = span[offset++];
				value |= (num & 0x7F) << 7;
				if ((num & 0x80) == 0)
				{
					return 2;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					state.ThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 14;
				if ((num & 0x80) == 0)
				{
					return 3;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					state.ThrowEoF();
				}
				num = span[offset++];
				value |= (num & 0x7F) << 21;
				if ((num & 0x80) == 0)
				{
					return 4;
				}
				if ((uint)offset >= (uint)span.Length)
				{
					state.ThrowEoF();
				}
				num = span[offset++];
				value |= num << 28;
				if ((num & 0xF0) == 0)
				{
					return 5;
				}
				if (trimNegative && (num & 0xF0) == 240 && offset + 4 < (uint)span.Length && span[offset] == byte.MaxValue && span[offset + 1] == byte.MaxValue && span[offset + 2] == byte.MaxValue && span[offset + 3] == byte.MaxValue && span[offset + 4] == 1)
				{
					return 10;
				}
				state.ThrowOverflow();
				return 0;
			}

			public override void Dispose()
			{
				base.Dispose();
				_source = default(ReadOnlySequence<byte>.Enumerator);
				Pool<ReadOnlySequenceProtoReader>.Put(this);
			}

			internal void Init(ReadOnlySequence<byte> source, TypeModel model, object userState)
			{
				Init(model, userState);
				_source = source.GetEnumerator();
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private int GetSomeData(ref State state, bool throwIfEOF = true)
			{
				int remainingInCurrent = state.RemainingInCurrent;
				if (remainingInCurrent != 0)
				{
					return remainingInCurrent;
				}
				return ReadNextBuffer(ref state, throwIfEOF);
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private int ReadNextBuffer(ref State state, bool throwIfEOF)
			{
				do
				{
					if (!_source.MoveNext())
					{
						if (throwIfEOF)
						{
							state.ThrowEoF();
						}
						return 0;
					}
					state.Init(_source.Current);
				}
				while (state.Span.IsEmpty);
				return state.Span.Length;
			}

			private protected override int ImplTryReadUInt64VarintWithoutMoving(ref State state, out ulong value)
			{
				if (state.RemainingInCurrent < 10)
				{
					return ViaStackAlloc(this, ref state, out value);
				}
				return State.TryParseUInt64Varint(state.Span, state.OffsetInCurrent, out value);
				static int ViaStackAlloc(ReadOnlySequenceProtoReader reader, ref State s, out ulong val)
				{
					Span<byte> span = stackalloc byte[10];
					Span<byte> destination = span;
					int num = 0;
					if (s.RemainingInCurrent != 0)
					{
						int num2 = Math.Min(s.RemainingInCurrent, destination.Length);
						Peek(ref s, num2).CopyTo(destination);
						destination = destination.Slice(num2);
						num += num2;
					}
					ReadOnlySequence<byte>.Enumerator source = reader._source;
					while (!destination.IsEmpty && source.MoveNext())
					{
						ReadOnlySpan<byte> span2 = source.Current.Span;
						int num3 = Math.Min(span2.Length, destination.Length);
						span2.Slice(0, num3).CopyTo(destination);
						destination = destination.Slice(num3);
						num += num3;
					}
					if (num != 10)
					{
						span = span.Slice(0, num);
					}
					return State.TryParseUInt64Varint(span, 0, out val);
				}
			}

			private protected override uint ImplReadUInt32Fixed(ref State state)
			{
				if (state.RemainingInCurrent < 4)
				{
					return ViaStackAlloc(ref state);
				}
				return BinaryPrimitives.ReadUInt32LittleEndian(Consume(ref state, 4));
				uint ViaStackAlloc(ref State st)
				{
					Span<byte> span = stackalloc byte[4];
					Span<byte> destination = span;
					while (!destination.IsEmpty)
					{
						int num = Math.Min(GetSomeData(ref st), destination.Length);
						Consume(ref st, num).CopyTo(destination);
						destination = destination.Slice(num);
					}
					return BinaryPrimitives.ReadUInt32LittleEndian(span);
				}
			}

			private protected override ulong ImplReadUInt64Fixed(ref State state)
			{
				if (state.RemainingInCurrent < 8)
				{
					return ViaStackAlloc(ref state);
				}
				return BinaryPrimitives.ReadUInt64LittleEndian(Consume(ref state, 8));
				ulong ViaStackAlloc(ref State st)
				{
					Span<byte> span = stackalloc byte[8];
					Span<byte> destination = span;
					while (!destination.IsEmpty)
					{
						int num = Math.Min(GetSomeData(ref st), destination.Length);
						Consume(ref st, num).CopyTo(destination);
						destination = destination.Slice(num);
					}
					return BinaryPrimitives.ReadUInt64LittleEndian(span);
				}
			}

			private protected override string ImplReadString(ref State state, int bytes)
			{
				if (state.RemainingInCurrent < bytes)
				{
					return ImplReadStringMultiSegment(ref state, bytes);
				}
				int offset;
				return ToString(Consume(ref state, bytes, out offset), offset, bytes);
			}

			private string ImplReadStringMultiSegment(ref State state, int bytes)
			{
				byte[] buffer = BufferPool.GetBuffer(bytes);
				try
				{
					Span<byte> span = new Span<byte>(buffer, 0, bytes);
					ImplReadBytes(ref state, span, bytes);
					return ToString(span);
				}
				finally
				{
					BufferPool.ReleaseBufferToPool(ref buffer);
				}
			}

			private void ImplReadBytes(ref State state, Span<byte> target, int bytesToRead)
			{
				if (state.RemainingInCurrent >= bytesToRead)
				{
					Consume(ref state, bytesToRead).CopyTo(target);
				}
				else
				{
					Looped(ref state, target);
				}
				void Looped(ref State st, Span<byte> ttarget)
				{
					int num;
					for (int i = 0; i < bytesToRead; i += num)
					{
						num = Math.Min(GetSomeData(ref st), bytesToRead - i);
						Consume(ref st, num).CopyTo(ttarget);
						ttarget = ttarget.Slice(num);
					}
				}
			}

			private protected override void ImplReadBytes(ref State state, Span<byte> target)
			{
				ImplReadBytes(ref state, target, target.Length);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private ReadOnlySpan<byte> Consume(ref State state, int bytes)
			{
				Advance(bytes);
				return state.Consume(bytes);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private ReadOnlySpan<byte> Consume(ref State state, int bytes, out int offset)
			{
				Advance(bytes);
				return state.Consume(bytes, out offset);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private static ReadOnlySpan<byte> Peek(ref State state, int bytes)
			{
				return state.Span.Slice(state.OffsetInCurrent, bytes);
			}

			private protected override int ImplTryReadUInt32VarintWithoutMoving(ref State state, Read32VarintMode mode, out uint value)
			{
				if (state.RemainingInCurrent < 10)
				{
					return ViaStackAlloc(ref state, mode, out value);
				}
				return TryParseUInt32Varint(ref state, state.OffsetInCurrent, mode == Read32VarintMode.Signed, out value, state.Span);
				unsafe int ViaStackAlloc(ref State s, Read32VarintMode m, out uint val)
				{
					byte* pointer = stackalloc byte[10];
					Span<byte> span = new Span<byte>(pointer, 10);
					Span<byte> destination = span;
					ReadOnlySpan<byte> readOnlySpan = Peek(ref s, Math.Min(destination.Length, s.RemainingInCurrent));
					readOnlySpan.CopyTo(destination);
					int num = readOnlySpan.Length;
					destination = destination.Slice(num);
					ReadOnlySequence<byte>.Enumerator source = _source;
					while (!destination.IsEmpty && source.MoveNext())
					{
						ReadOnlySpan<byte> span2 = source.Current.Span;
						int num2 = Math.Min(span2.Length, destination.Length);
						span2.Slice(0, num2).CopyTo(destination);
						destination = destination.Slice(num2);
						num += num2;
					}
					if (num != 10)
					{
						span = span.Slice(0, num);
					}
					return TryParseUInt32Varint(ref s, 0, m == Read32VarintMode.Signed, out val, span);
				}
			}

			private protected override void ImplSkipBytes(ref State state, long count)
			{
				if (state.RemainingInCurrent >= count)
				{
					Skip(ref state, (int)count);
				}
				else
				{
					Looped(ref state, count);
				}
				void Looped(ref State st, long ccount)
				{
					while (ccount != 0L)
					{
						int num = (int)Math.Min(GetSomeData(ref st), ccount);
						Skip(ref st, num);
						ccount -= num;
					}
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void Skip(ref State state, int bytes)
			{
				state.Skip(bytes);
				Advance(bytes);
			}

			private protected override bool IsFullyConsumed(ref State state)
			{
				return GetSomeData(ref state, throwIfEOF: false) == 0;
			}
		}

		[StructLayout(LayoutKind.Auto)]
		internal readonly struct SolidState : IDisposable
		{
			private readonly ReadOnlyMemory<byte> _memory;

			private readonly ProtoReader _reader;

			public void Dispose()
			{
				_reader?.Dispose();
			}

			internal SolidState(ProtoReader reader, ReadOnlyMemory<byte> memory)
			{
				_memory = memory;
				_reader = reader;
			}

			internal State Liquify()
			{
				return new State(_reader, _memory);
			}
		}

		private sealed class StreamProtoReader : ProtoReader
		{
			private Stream _source;

			private byte[] _ioBuffer;

			private bool _isFixedLength;

			private int _ioIndex;

			private int _available;

			private long _dataRemaining64;

			protected internal override State DefaultState()
			{
				return new State(this);
			}

			[Obsolete("Please use ProtoReader.Create; this API may be removed in a future version", false)]
			public StreamProtoReader(Stream source, TypeModel model, SerializationContext context, int length)
			{
				Init(source, model, context, length);
			}

			[Obsolete("Please use ProtoReader.Create; this API may be removed in a future version", false)]
			public StreamProtoReader(Stream source, TypeModel model, SerializationContext context, long length)
			{
				Init(source, model, context, length);
			}

			internal StreamProtoReader()
			{
			}

			[Obsolete("Please use ProtoReader.Create; this API may be removed in a future version", false)]
			public StreamProtoReader(Stream source, TypeModel model, SerializationContext context)
			{
				Init(source, model, context, -1L);
			}

			internal void Init(Stream source, TypeModel model, object userState, long length)
			{
				Init(model, userState);
				if (source == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("source");
				}
				if (!source.CanRead)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("Cannot read from stream", "source");
				}
				if (TryConsumeSegmentRespectingPosition(source, out var data, length))
				{
					_ioBuffer = data.Array;
					length = (_available = data.Count);
					_ioIndex = data.Offset;
				}
				else
				{
					_source = source;
					_ioBuffer = BufferPool.GetBuffer();
					_available = (_ioIndex = 0);
					_dataRemaining64 = ((_isFixedLength = length >= 0) ? length : 0);
				}
			}

			public override void Dispose()
			{
				base.Dispose();
				if (_source != null)
				{
					_source = null;
					BufferPool.ReleaseBufferToPool(ref _ioBuffer);
				}
				else
				{
					_ioBuffer = null;
				}
				Pool<StreamProtoReader>.Put(this);
			}

			private protected override int ImplTryReadUInt32VarintWithoutMoving(ref State state, Read32VarintMode mode, out uint value)
			{
				if (_available < 10)
				{
					Ensure(ref state, 10, strict: false);
				}
				if (_available == 0)
				{
					value = 0u;
					return 0;
				}
				int ioIndex = _ioIndex;
				value = _ioBuffer[ioIndex++];
				if ((value & 0x80) == 0)
				{
					return 1;
				}
				value &= 127u;
				if (_available == 1)
				{
					state.ThrowEoF();
				}
				uint num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 7;
				if ((num & 0x80) == 0)
				{
					return 2;
				}
				if (_available == 2)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 14;
				if ((num & 0x80) == 0)
				{
					return 3;
				}
				if (_available == 3)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 21;
				if ((num & 0x80) == 0)
				{
					return 4;
				}
				if (_available == 4)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex];
				value |= num << 28;
				if ((num & 0xF0) == 0)
				{
					return 5;
				}
				if (mode == Read32VarintMode.Signed && (num & 0xF0) == 240 && _available >= 10 && _ioBuffer[++ioIndex] == byte.MaxValue && _ioBuffer[++ioIndex] == byte.MaxValue && _ioBuffer[++ioIndex] == byte.MaxValue && _ioBuffer[++ioIndex] == byte.MaxValue && _ioBuffer[++ioIndex] == 1)
				{
					return 10;
				}
				state.ThrowOverflow();
				return 0;
			}

			private protected override ulong ImplReadUInt64Fixed(ref State state)
			{
				if (_available < 8)
				{
					Ensure(ref state, 8, strict: true);
				}
				Advance(8L);
				_available -= 8;
				ulong result = BinaryPrimitives.ReadUInt64LittleEndian(MemoryExtensions.AsSpan(_ioBuffer, _ioIndex, 8));
				_ioIndex += 8;
				return result;
			}

			private protected override void ImplReadBytes(ref State state, Span<byte> target)
			{
				int num = target.Length;
				Advance(num);
				while (num > _available)
				{
					if (_available > 0)
					{
						new Span<byte>(_ioBuffer, _ioIndex, _available).CopyTo(target);
						num -= _available;
						target = target.Slice(_available);
						_ioIndex = (_available = 0);
					}
					int num2 = ((num > _ioBuffer.Length) ? _ioBuffer.Length : num);
					if (num2 > 0)
					{
						Ensure(ref state, num2, strict: true);
					}
				}
				if (num > 0)
				{
					new Span<byte>(_ioBuffer, _ioIndex, num).CopyTo(target);
					_available -= num;
					_ioIndex += num;
				}
			}

			private protected override int ImplTryReadUInt64VarintWithoutMoving(ref State state, out ulong value)
			{
				if (_available < 10)
				{
					Ensure(ref state, 10, strict: false);
				}
				if (_available == 0)
				{
					value = 0uL;
					return 0;
				}
				int ioIndex = _ioIndex;
				value = _ioBuffer[ioIndex++];
				if ((value & 0x80) == 0L)
				{
					return 1;
				}
				value &= 127uL;
				if (_available == 1)
				{
					state.ThrowEoF();
				}
				ulong num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 7;
				if ((num & 0x80) == 0L)
				{
					return 2;
				}
				if (_available == 2)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 14;
				if ((num & 0x80) == 0L)
				{
					return 3;
				}
				if (_available == 3)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 21;
				if ((num & 0x80) == 0L)
				{
					return 4;
				}
				if (_available == 4)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 28;
				if ((num & 0x80) == 0L)
				{
					return 5;
				}
				if (_available == 5)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 35;
				if ((num & 0x80) == 0L)
				{
					return 6;
				}
				if (_available == 6)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 42;
				if ((num & 0x80) == 0L)
				{
					return 7;
				}
				if (_available == 7)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 49;
				if ((num & 0x80) == 0L)
				{
					return 8;
				}
				if (_available == 8)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex++];
				value |= (num & 0x7F) << 56;
				if ((num & 0x80) == 0L)
				{
					return 9;
				}
				if (_available == 9)
				{
					state.ThrowEoF();
				}
				num = _ioBuffer[ioIndex];
				value |= num << 63;
				if ((num & 0xFFFFFFFFFFFFFFFEuL) != 0L)
				{
					state.ThrowOverflow();
				}
				return 10;
			}

			private protected override string ImplReadString(ref State state, int bytes)
			{
				if (_available < bytes)
				{
					Ensure(ref state, bytes, strict: true);
				}
				string @string = UTF8.GetString(_ioBuffer, _ioIndex, bytes);
				_available -= bytes;
				Advance(bytes);
				_ioIndex += bytes;
				return @string;
			}

			private protected override bool IsFullyConsumed(ref State state)
			{
				return (_isFixedLength ? _dataRemaining64 : _available) == 0;
			}

			private protected override uint ImplReadUInt32Fixed(ref State state)
			{
				if (_available < 4)
				{
					Ensure(ref state, 4, strict: true);
				}
				Advance(4L);
				_available -= 4;
				uint result = BinaryPrimitives.ReadUInt32LittleEndian(MemoryExtensions.AsSpan(_ioBuffer, _ioIndex, 4));
				_ioIndex += 4;
				return result;
			}

			private void Ensure(ref State state, int count, bool strict)
			{
				if (_source != null)
				{
					if (count > _ioBuffer.Length)
					{
						BufferPool.ResizeAndFlushLeft(ref _ioBuffer, count, _ioIndex, _available);
						_ioIndex = 0;
					}
					else if (_ioIndex + count >= _ioBuffer.Length)
					{
						Buffer.BlockCopy(_ioBuffer, _ioIndex, _ioBuffer, 0, _available);
						_ioIndex = 0;
					}
					count -= _available;
					int num = _ioIndex + _available;
					int num2 = _ioBuffer.Length - num;
					if (_isFixedLength && _dataRemaining64 < num2)
					{
						num2 = (int)_dataRemaining64;
					}
					int num3;
					while (count > 0 && num2 > 0 && (num3 = _source.Read(_ioBuffer, num, num2)) > 0)
					{
						_available += num3;
						count -= num3;
						num2 -= num3;
						num += num3;
						if (_isFixedLength)
						{
							_dataRemaining64 -= num3;
						}
					}
				}
				if (strict && count > 0)
				{
					state.ThrowEoF();
				}
			}

			private protected override void ImplSkipBytes(ref State state, long count)
			{
				if (_available < count && count < 128)
				{
					Ensure(ref state, (int)count, strict: true);
				}
				if (count <= _available)
				{
					_available -= (int)count;
					_ioIndex += (int)count;
					Advance(count);
					return;
				}
				Advance(count);
				count -= _available;
				_ioIndex = (_available = 0);
				if (_isFixedLength)
				{
					if (count > _dataRemaining64)
					{
						state.ThrowEoF();
					}
					_dataRemaining64 -= count;
				}
				if (_source == null)
				{
					state.ThrowEoF();
				}
				Seek(_source, count, _ioBuffer);
			}
		}

		internal const string PreferStateAPI = "If possible, please use the State API; a transitionary implementation is provided, but this API may be removed in a future version";

		internal const string PreferReadMessage = "If possible, please use the ReadMessage API; this API may not work correctly with all readers";

		private TypeModel _model;

		private int _fieldNumber;

		private int _depth;

		private long blockEnd64;

		private readonly NetObjectCache netCache = new NetObjectCache();

		internal const long TO_EOF = -1L;

		private long _longPosition;

		private Dictionary<string, string> stringInterner;

		private protected static readonly UTF8Encoding UTF8 = new UTF8Encoding();

		internal static readonly byte[] EmptyBlob = Array.Empty<byte>();

		internal const MethodImplOptions HotPath = MethodImplOptions.AggressiveInlining;

		private static readonly FieldInfo s_origin = typeof(MemoryStream).GetField("_origin", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo s_buffer = typeof(MemoryStream).GetField("_buffer", BindingFlags.Instance | BindingFlags.NonPublic);

		public int FieldNumber
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _fieldNumber;
			}
		}

		public WireType WireType
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get;
			private protected set; }

		public bool InternStrings { get; set; }

		public object UserState { get; private set; }

		[Obsolete("Prefer UserState")]
		public SerializationContext Context => SerializationContext.AsSerializationContext(this);

		public int Position
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return checked((int)_longPosition);
			}
		}

		public long LongPosition
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return _longPosition;
			}
		}

		public TypeModel Model
		{
			get
			{
				return _model;
			}
			internal set
			{
				_model = value;
			}
		}

		private protected abstract int ImplTryReadUInt64VarintWithoutMoving(ref State state, out ulong value);

		private protected abstract uint ImplReadUInt32Fixed(ref State state);

		private protected abstract ulong ImplReadUInt64Fixed(ref State state);

		private protected abstract string ImplReadString(ref State state, int bytes);

		private protected abstract void ImplSkipBytes(ref State state, long count);

		private protected abstract int ImplTryReadUInt32VarintWithoutMoving(ref State state, Read32VarintMode mode, out uint value);

		private protected abstract void ImplReadBytes(ref State state, Span<byte> target);

		private protected virtual void ImplReadBytes(ref State state, ReadOnlySequence<byte> target)
		{
			if (target.IsSingleSegment)
			{
				ImplReadBytes(ref state, MemoryMarshal.AsMemory(target.First).Span);
				return;
			}
			ReadOnlySequence<byte>.Enumerator enumerator = target.GetEnumerator();
			while (enumerator.MoveNext())
			{
				ReadOnlyMemory<byte> current = enumerator.Current;
				ImplReadBytes(ref state, MemoryMarshal.AsMemory(current).Span);
			}
		}

		private protected abstract bool IsFullyConsumed(ref State state);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private bool IncrDepth()
		{
			return ++_depth >= ((_model == null) ? 512 : _model.MaxDepth);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private void DecrDepth()
		{
			_depth--;
		}

		private protected ProtoReader()
		{
		}

		internal void Init(TypeModel model, object userState)
		{
			_model = model;
			if (userState is SerializationContext serializationContext)
			{
				serializationContext.Freeze();
			}
			UserState = userState;
			_longPosition = 0L;
			_depth = (_fieldNumber = 0);
			blockEnd64 = long.MaxValue;
			InternStrings = model.HasOption(TypeModel.TypeModelOptions.InternStrings);
			WireType = WireType.None;
		}

		public virtual void Dispose()
		{
			_model = null;
			if (stringInterner != null)
			{
				stringInterner.Clear();
				stringInterner = null;
			}
			netCache.Clear();
			UserState = null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void Advance(long count)
		{
			_longPosition += count;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public short ReadInt16()
		{
			return DefaultState().ReadInt16();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ushort ReadUInt16()
		{
			return DefaultState().ReadUInt16();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public byte ReadByte()
		{
			return DefaultState().ReadByte();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public sbyte ReadSByte()
		{
			return DefaultState().ReadSByte();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public uint ReadUInt32()
		{
			return DefaultState().ReadUInt32();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int ReadInt32()
		{
			return DefaultState().ReadInt32();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public long ReadInt64()
		{
			return DefaultState().ReadInt64();
		}

		private protected string Intern(string value)
		{
			if (value == null)
			{
				return null;
			}
			if (value.Length == 0)
			{
				return "";
			}
			string value2;
			if (stringInterner == null)
			{
				stringInterner = new Dictionary<string, string>(StringComparer.Ordinal) { { value, value } };
			}
			else if (stringInterner.TryGetValue(value, out value2))
			{
				value = value2;
			}
			else
			{
				stringInterner.Add(value, value);
			}
			return value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public string ReadString()
		{
			return DefaultState().ReadString();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public void ThrowEnumException(Type type, int value)
		{
			DefaultState().ThrowEnumException(type, value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public double ReadDouble()
		{
			return DefaultState().ReadDouble();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static object ReadObject(object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ProtoReader reader)
		{
			return reader.DefaultState().ReadObject(value, type);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void EndSubItem(SubItemToken token, ProtoReader reader)
		{
			reader.DefaultState().EndSubItem(token);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SubItemToken StartSubItem(ProtoReader reader)
		{
			return reader.DefaultState().StartSubItem();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public int ReadFieldHeader()
		{
			return DefaultState().ReadFieldHeader();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private int SetTag(uint tag)
		{
			if ((_fieldNumber = (int)(tag >> 3)) < 1)
			{
				ThrowInvalidField(_fieldNumber);
			}
			WireType wireType2 = (WireType = (WireType)((int)tag & 7));
			if (wireType2 == WireType.EndGroup)
			{
				if (_depth > 0)
				{
					return 0;
				}
				ThrowUnexpectedEndGroup();
			}
			return _fieldNumber;
		}

		private static void ThrowInvalidField(int fieldNumber)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowProtoException("Invalid field in source data: " + fieldNumber);
		}

		private static void ThrowUnexpectedEndGroup()
		{
			ProtoBuf.Internal.ThrowHelper.ThrowProtoException("Unexpected end-group in source data; this usually means the source data is corrupt");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool TryReadFieldHeader(int field)
		{
			return DefaultState().TryReadFieldHeader(field);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Hint(WireType wireType)
		{
			if (WireType != wireType && (wireType & (WireType)7) == WireType)
			{
				WireType = wireType;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Assert(WireType wireType)
		{
			DefaultState().Assert(wireType);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void SkipField()
		{
			DefaultState().SkipField();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public ulong ReadUInt64()
		{
			return DefaultState().ReadUInt64();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public float ReadSingle()
		{
			return DefaultState().ReadSingle();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public bool ReadBoolean()
		{
			return DefaultState().ReadBoolean();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static byte[] AppendBytes(byte[] value, ProtoReader reader)
		{
			return reader.DefaultState().AppendBytes(value);
		}

		private static int ReadByteOrThrow(Stream source)
		{
			int num = source.ReadByte();
			if (num < 0)
			{
				ThrowEoF();
			}
			return num;
		}

		public static int ReadLengthPrefix(Stream source, bool expectHeader, PrefixStyle style, out int fieldNumber)
		{
			int bytesRead;
			return ReadLengthPrefix(source, expectHeader, style, out fieldNumber, out bytesRead);
		}

		public static int DirectReadLittleEndianInt32(Stream source)
		{
			return ReadByteOrThrow(source) | (ReadByteOrThrow(source) << 8) | (ReadByteOrThrow(source) << 16) | (ReadByteOrThrow(source) << 24);
		}

		public static int DirectReadBigEndianInt32(Stream source)
		{
			return (ReadByteOrThrow(source) << 24) | (ReadByteOrThrow(source) << 16) | (ReadByteOrThrow(source) << 8) | ReadByteOrThrow(source);
		}

		public static int DirectReadVarintInt32(Stream source)
		{
			ulong value;
			int num = TryReadUInt64Varint(source, out value);
			if (num <= 0)
			{
				ThrowEoF();
			}
			return checked((int)value);
		}

		public static void DirectReadBytes(Stream source, byte[] buffer, int offset, int count)
		{
			if (source == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("source");
			}
			int num;
			while (count > 0 && (num = source.Read(buffer, offset, count)) > 0)
			{
				count -= num;
				offset += num;
			}
			if (count > 0)
			{
				ThrowEoF();
			}
		}

		public static byte[] DirectReadBytes(Stream source, int count)
		{
			byte[] array = new byte[count];
			DirectReadBytes(source, array, 0, count);
			return array;
		}

		public static string DirectReadString(Stream source, int length)
		{
			byte[] array = new byte[length];
			DirectReadBytes(source, array, 0, length);
			return ProtoWriter.UTF8.GetString(array, 0, length);
		}

		public static int ReadLengthPrefix(Stream source, bool expectHeader, PrefixStyle style, out int fieldNumber, out int bytesRead)
		{
			if (style == PrefixStyle.None)
			{
				bytesRead = (fieldNumber = 0);
				return int.MaxValue;
			}
			long num = ReadLongLengthPrefix(source, expectHeader, style, out fieldNumber, out bytesRead);
			return checked((int)num);
		}

		public static long ReadLongLengthPrefix(Stream source, bool expectHeader, PrefixStyle style, out int fieldNumber, out int bytesRead)
		{
			fieldNumber = 0;
			switch (style)
			{
			case PrefixStyle.None:
				bytesRead = 0;
				return long.MaxValue;
			case PrefixStyle.Base128:
			{
				bytesRead = 0;
				ulong value;
				int num2;
				if (expectHeader)
				{
					num2 = TryReadUInt64Varint(source, out value);
					bytesRead += num2;
					if (num2 > 0)
					{
						if ((value & 7) != 2)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Unexpected wire-type: {(WireType)(value & 7)}, expected {WireType.String})");
						}
						fieldNumber = (int)(value >> 3);
						num2 = TryReadUInt64Varint(source, out value);
						bytesRead += num2;
						if (bytesRead == 0)
						{
							ThrowEoF();
						}
						return (long)value;
					}
					bytesRead = 0;
					return -1L;
				}
				num2 = TryReadUInt64Varint(source, out value);
				bytesRead += num2;
				if (bytesRead >= 0)
				{
					return (long)value;
				}
				return -1L;
			}
			case PrefixStyle.Fixed32:
			{
				int num3 = source.ReadByte();
				if (num3 < 0)
				{
					bytesRead = 0;
					return -1L;
				}
				bytesRead = 4;
				return num3 | (ReadByteOrThrow(source) << 8) | (ReadByteOrThrow(source) << 16) | (ReadByteOrThrow(source) << 24);
			}
			case PrefixStyle.Fixed32BigEndian:
			{
				int num = source.ReadByte();
				if (num < 0)
				{
					bytesRead = 0;
					return -1L;
				}
				bytesRead = 4;
				return (num << 24) | (ReadByteOrThrow(source) << 16) | (ReadByteOrThrow(source) << 8) | ReadByteOrThrow(source);
			}
			default:
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("style");
				bytesRead = 0;
				return 0L;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowEoF()
		{
			default(State).ThrowEoF();
		}

		private static int TryReadUInt64Varint(Stream source, out ulong value)
		{
			value = 0uL;
			int num = source.ReadByte();
			if (num < 0)
			{
				return 0;
			}
			value = (uint)num;
			if ((value & 0x80) == 0L)
			{
				return 1;
			}
			value &= 127uL;
			int num2 = 1;
			int num3 = 7;
			while (num2 < 9)
			{
				num = source.ReadByte();
				if (num < 0)
				{
					ThrowEoF();
				}
				value |= ((ulong)num & 0x7FuL) << num3;
				num3 += 7;
				num2++;
				if ((num & 0x80) == 0)
				{
					return num2;
				}
			}
			num = source.ReadByte();
			if (num < 0)
			{
				ThrowEoF();
			}
			if ((num & 1) == 0)
			{
				value |= ((ulong)num & 0x7FuL) << num3;
				return ++num2;
			}
			ProtoBuf.Internal.ThrowHelper.ThrowOverflowException();
			return 0;
		}

		internal static void Seek(Stream source, long count, byte[] buffer)
		{
			if (source.CanSeek)
			{
				source.Seek(count, SeekOrigin.Current);
				count = 0L;
			}
			else if (buffer != null)
			{
				int num;
				while (count > buffer.Length && (num = source.Read(buffer, 0, buffer.Length)) > 0)
				{
					count -= num;
				}
				while (count > 0 && (num = source.Read(buffer, 0, (int)count)) > 0)
				{
					count -= num;
				}
			}
			else
			{
				buffer = BufferPool.GetBuffer();
				try
				{
					int num2;
					while (count > buffer.Length && (num2 = source.Read(buffer, 0, buffer.Length)) > 0)
					{
						count -= num2;
					}
					while (count > 0 && (num2 = source.Read(buffer, 0, (int)count)) > 0)
					{
						count -= num2;
					}
				}
				finally
				{
					BufferPool.ReleaseBufferToPool(ref buffer);
				}
			}
			if (count > 0)
			{
				ThrowEoF();
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void AppendExtensionData(IExtensible instance)
		{
			DefaultState().AppendExtensionData(instance);
		}

		public static bool HasSubValue(WireType wireType, ProtoReader source)
		{
			if (source == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("source");
			}
			if (source.blockEnd64 <= source._longPosition || wireType == WireType.EndGroup)
			{
				return false;
			}
			source.WireType = wireType;
			return true;
		}

		internal Type DeserializeType(string value)
		{
			return TypeModel.DeserializeType(_model, value);
		}

		public Type ReadType()
		{
			return DefaultState().ReadType();
		}

		public static object Merge(ProtoReader parent, object from, object to)
		{
			if (parent == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("parent");
			}
			TypeModel model = parent.Model;
			object userState = parent.UserState;
			if (model == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Types cannot be merged unless a type-model has been specified");
			}
			using MemoryStream memoryStream = new MemoryStream();
			ProtoWriter.State state = ProtoWriter.State.Create(memoryStream, model, userState);
			try
			{
				model.SerializeRootFallback(ref state, from);
			}
			finally
			{
				state.Dispose();
			}
			memoryStream.Position = 0L;
			using State state2 = State.Create(memoryStream, model, userState, -1L);
			return state2.DeserializeRootFallback(to, null);
		}

		protected internal abstract State DefaultState();

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void NoContextThrowEoF()
		{
			default(State).ThrowEoF();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void NoContextThrowOverflow()
		{
			default(State).ThrowOverflow();
		}

		[Obsolete("If possible, please use the State API; a transitionary implementation is provided, but this API may be removed in a future version", false)]
		public static ProtoReader Create(Stream source, TypeModel model, SerializationContext context = null, long length = -1L)
		{
			return Create(source, model, (object)context, length);
		}

		internal static ProtoReader Create(Stream source, TypeModel model, object userState, long length)
		{
			StreamProtoReader streamProtoReader = Pool<StreamProtoReader>.TryGet() ?? new StreamProtoReader();
			streamProtoReader.Init(source, model ?? TypeModel.DefaultModel, userState, length);
			return streamProtoReader;
		}

		private static bool ReflectionTryGetBuffer(MemoryStream ms, out ArraySegment<byte> buffer)
		{
			if ((object)s_origin != null && (object)s_buffer != null && ms.GetType() == typeof(MemoryStream))
			{
				try
				{
					int offset = (int)s_origin.GetValue(ms);
					byte[] array = (byte[])s_buffer.GetValue(ms);
					buffer = new ArraySegment<byte>(array, offset, checked((int)ms.Length));
					return true;
				}
				catch
				{
				}
			}
			buffer = default(ArraySegment<byte>);
			return false;
		}

		internal static bool TryConsumeSegmentRespectingPosition(Stream source, out ArraySegment<byte> data, long length)
		{
			if (source is MemoryStream memoryStream && memoryStream.CanSeek && (memoryStream.TryGetBuffer(out var buffer) || ReflectionTryGetBuffer(memoryStream, out buffer)))
			{
				int num = checked((int)memoryStream.Position);
				int num2 = buffer.Count - num;
				int offset = buffer.Offset + num;
				if (length >= 0 && length < num2)
				{
					num2 = (int)length;
				}
				data = new ArraySegment<byte>(buffer.Array, offset, num2);
				memoryStream.Seek(num2, SeekOrigin.Current);
				return true;
			}
			data = default(ArraySegment<byte>);
			return false;
		}
	}
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum, AllowMultiple = true, Inherited = false)]
	internal sealed class ProtoReservedAttribute : Attribute
	{
		public int From { get; }

		public int To { get; }

		public string Name { get; }

		public string Comment { get; }

		public ProtoReservedAttribute(int field, string comment = null)
			: this(field, field, comment)
		{
		}

		public ProtoReservedAttribute(int from, int to, string comment = null)
		{
			From = from;
			To = to;
			Comment = comment;
		}

		public ProtoReservedAttribute(string field, string comment = null)
		{
			Name = field;
			Comment = comment;
		}

		internal void Verify()
		{
			if (string.IsNullOrWhiteSpace(Name))
			{
				if (From <= 0)
				{
					throw new ArgumentOutOfRangeException("From", "Invalid reservation definition");
				}
				if (To < From)
				{
					throw new ArgumentOutOfRangeException("To", "Invalid reservation definition");
				}
			}
		}
	}
	internal abstract class ProtoWriter : IDisposable, ISerializationContext
	{
		[StructLayout(LayoutKind.Auto)]
		public ref struct State
		{
			private Span<byte> _span;

			private Memory<byte> _memory;

			private ProtoWriter _writer;

			internal bool IsActive => !_span.IsEmpty;

			internal Span<byte> Remaining
			{
				[MethodImpl(MethodImplOptions.AggressiveInlining)]
				get
				{
					return _span.Slice(OffsetInCurrent);
				}
			}

			internal int RemainingInCurrent { get; private set; }

			internal int OffsetInCurrent { get; private set; }

			internal TypeModel Model => _writer?.Model;

			internal WireType WireType
			{
				get
				{
					return _writer.WireType;
				}
				set
				{
					_writer.WireType = value;
				}
			}

			internal int Depth => _writer.Depth;

			internal int FieldNumber
			{
				get
				{
					return _writer.fieldNumber;
				}
				private set
				{
					_writer.fieldNumber = value;
				}
			}

			public ISerializationContext Context => _writer;

			public static State Create(IBufferWriter<byte> writer, TypeModel model, object userState = null)
			{
				return BufferWriterProtoWriter.CreateBufferWriterProtoWriter(writer, model, userState);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal State(ProtoWriter writer)
			{
				this = default(State);
				_writer = writer;
			}

			internal void Init(Memory<byte> memory)
			{
				_memory = memory;
				_span = memory.Span;
				RemainingInCurrent = _span.Length;
			}

			public void Flush()
			{
				if (_writer.TryFlush(ref this))
				{
					_writer._needFlush = false;
				}
			}

			internal int ConsiderWritten()
			{
				int offsetInCurrent = OffsetInCurrent;
				ProtoWriter writer = _writer;
				this = default(State);
				_writer = writer;
				return offsetInCurrent;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void LocalWriteFixed32(uint value)
			{
				BinaryPrimitives.WriteUInt32LittleEndian(Remaining, value);
				OffsetInCurrent += 4;
				RemainingInCurrent -= 4;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void ReverseLast32()
			{
				_span.Slice(OffsetInCurrent - 4, 4).Reverse();
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void LocalAdvance(int bytes)
			{
				OffsetInCurrent += bytes;
				RemainingInCurrent -= bytes;
			}

			internal void LocalWriteBytes(ReadOnlySpan<byte> span)
			{
				span.CopyTo(Remaining);
				OffsetInCurrent += span.Length;
				RemainingInCurrent -= span.Length;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal void LocalWriteFixed64(ulong value)
			{
				BinaryPrimitives.WriteUInt64LittleEndian(Remaining, value);
				OffsetInCurrent += 8;
				RemainingInCurrent -= 8;
			}

			internal unsafe void LocalWriteString(string value)
			{
				int bytes;
				fixed (char* chars = value)
				{
					fixed (byte* ptr = &MemoryMarshal.GetReference(_span))
					{
						bytes = UTF8.GetBytes(chars, value.Length, ptr + OffsetInCurrent, RemainingInCurrent);
					}
				}
				OffsetInCurrent += bytes;
				RemainingInCurrent -= bytes;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal int LocalWriteVarint64(ulong value)
			{
				int num = WriteVarint64(value, _span, OffsetInCurrent);
				OffsetInCurrent += num;
				RemainingInCurrent -= num;
				return num;
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal static int WriteVarint64(ulong value, Span<byte> span, int offset = 0)
			{
				int num = 0;
				do
				{
					span[offset++] = (byte)((value & 0x7F) | 0x80);
					num++;
				}
				while ((value >>= 7) != 0L);
				span[offset - 1] &= 127;
				return num;
			}

			internal int ReadFrom(Stream source)
			{
				int num;
				if (MemoryMarshal.TryGetArray((ReadOnlyMemory<byte>)_memory, out ArraySegment<byte> segment))
				{
					num = source.Read(segment.Array, segment.Offset + OffsetInCurrent, RemainingInCurrent);
				}
				else
				{
					byte[] array = ArrayPool<byte>.Shared.Rent(RemainingInCurrent);
					try
					{
						num = source.Read(array, 0, RemainingInCurrent);
						if (num > 0)
						{
							new Span<byte>(array, 0, num).CopyTo(Remaining);
						}
					}
					finally
					{
						ArrayPool<byte>.Shared.Return(array);
					}
				}
				if (num > 0)
				{
					OffsetInCurrent += num;
					RemainingInCurrent -= num;
				}
				return num;
			}

			internal int LocalWriteVarint32(uint value)
			{
				int num = 0;
				Span<byte> span = _span;
				int offsetInCurrent = OffsetInCurrent;
				do
				{
					span[offsetInCurrent++] = (byte)((value & 0x7Fu) | 0x80u);
					num++;
				}
				while ((value >>= 7) != 0);
				span[offsetInCurrent - 1] &= 127;
				OffsetInCurrent += num;
				RemainingInCurrent -= num;
				return num;
			}

			public void WriteString(int fieldNumber, string value, StringMap map = null)
			{
				if (value != null)
				{
					WriteFieldHeader(fieldNumber, WireType.String);
					WriteStringWithLengthPrefix(value, map);
				}
			}

			private void WriteStringWithLengthPrefix(string value, StringMap map)
			{
				ProtoWriter writer = _writer;
				if (string.IsNullOrEmpty(value))
				{
					writer.AdvanceAndReset(writer.ImplWriteVarint32(ref this, 0u));
					return;
				}
				int byteCount = UTF8.GetByteCount(value);
				writer.AdvanceAndReset(writer.ImplWriteVarint32(ref this, (uint)byteCount) + byteCount);
				writer.ImplWriteString(ref this, value, byteCount);
			}

			public void WriteString(string value, StringMap map = null)
			{
				WireType wireType = _writer.WireType;
				if (wireType == WireType.String)
				{
					WriteStringWithLengthPrefix(value, map);
				}
				else
				{
					ThrowInvalidSerializationOperation();
				}
			}

			public void WriteType(Type value)
			{
				WriteString(_writer.SerializeType(value));
			}

			public void WriteFieldHeader(int fieldNumber, WireType wireType)
			{
				ProtoWriter writer2 = _writer;
				if (writer2.WireType != WireType.None)
				{
					FailPendingField(writer2, fieldNumber, wireType);
				}
				if (fieldNumber < 0)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("fieldNumber");
				}
				writer2._needFlush = true;
				if (writer2.packedFieldNumber == 0)
				{
					writer2.fieldNumber = fieldNumber;
					writer2.WireType = wireType;
					WriteHeaderCore(fieldNumber, wireType);
				}
				else
				{
					WritePackedField(writer2, fieldNumber, wireType);
				}
				static void FailPendingField(ProtoWriter writer, int fieldNumber, WireType wireType)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Cannot write a {wireType}/{fieldNumber} header until the {writer.WireType}/{writer.fieldNumber} data has been written; writer: {writer}");
				}
				static void WritePackedField(ProtoWriter writer, int fieldNumber, WireType wireType)
				{
					if (writer.packedFieldNumber == fieldNumber)
					{
						if ((uint)wireType > 1u && wireType != WireType.Fixed32 && wireType != WireType.SignedVariant)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Wire-type cannot be encoded as packed: " + wireType);
						}
						writer.fieldNumber = fieldNumber;
						writer.WireType = wireType;
					}
					else
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber + " but received " + fieldNumber);
					}
				}
			}

			public void WriteInt32Varint(int fieldNumber, int value)
			{
				WriteFieldHeader(fieldNumber, WireType.Variant);
				WriteInt32VarintImpl(value);
			}

			private void WriteInt32VarintImpl(int value)
			{
				ProtoWriter writer = _writer;
				if (value >= 0)
				{
					writer.AdvanceAndReset(writer.ImplWriteVarint32(ref this, (uint)value));
				}
				else
				{
					writer.AdvanceAndReset(writer.ImplWriteVarint64(ref this, (ulong)value));
				}
			}

			public void WriteInt32(int value)
			{
				ProtoWriter writer = _writer;
				switch (writer.WireType)
				{
				case WireType.Fixed32:
					writer.ImplWriteFixed32(ref this, (uint)value);
					writer.AdvanceAndReset(4);
					break;
				case WireType.Fixed64:
					writer.ImplWriteFixed64(ref this, (ulong)value);
					writer.AdvanceAndReset(8);
					break;
				case WireType.Variant:
					WriteInt32VarintImpl(value);
					break;
				case WireType.SignedVariant:
					writer.AdvanceAndReset(writer.ImplWriteVarint32(ref this, Zig(value)));
					break;
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			public void WriteSByte(sbyte value)
			{
				WriteInt32(value);
			}

			public void WriteInt16(short value)
			{
				WriteInt32(value);
			}

			public void WriteUInt16(ushort value)
			{
				WriteUInt32(value);
			}

			public void WriteByte(byte value)
			{
				WriteUInt32(value);
			}

			public void WriteBoolean(bool value)
			{
				WriteUInt32(value ? 1u : 0u);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteIntPtr(IntPtr value)
			{
				WriteInt64(value.ToInt64());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteUIntPtr(UIntPtr value)
			{
				WriteUInt64(value.ToUInt64());
			}

			public void WriteUInt32(uint value)
			{
				ProtoWriter writer = _writer;
				switch (writer.WireType)
				{
				case WireType.Fixed32:
					writer.ImplWriteFixed32(ref this, value);
					writer.AdvanceAndReset(4);
					break;
				case WireType.Fixed64:
					writer.ImplWriteFixed64(ref this, value);
					writer.AdvanceAndReset(8);
					break;
				case WireType.Variant:
				{
					int count = writer.ImplWriteVarint32(ref this, value);
					writer.AdvanceAndReset(count);
					break;
				}
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			public unsafe void WriteDouble(double value)
			{
				ProtoWriter writer = _writer;
				switch (writer.WireType)
				{
				case WireType.Fixed32:
				{
					float num = (float)value;
					if (float.IsInfinity(num) && !double.IsInfinity(value))
					{
						ProtoBuf.Internal.ThrowHelper.ThrowOverflowException();
					}
					WriteSingle(num);
					break;
				}
				case WireType.Fixed64:
					writer.ImplWriteFixed64(ref this, *(ulong*)(&value));
					writer.AdvanceAndReset(8);
					break;
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			public unsafe void WriteSingle(float value)
			{
				ProtoWriter writer = _writer;
				switch (writer.WireType)
				{
				case WireType.Fixed32:
					writer.ImplWriteFixed32(ref this, *(uint*)(&value));
					writer.AdvanceAndReset(4);
					break;
				case WireType.Fixed64:
					WriteDouble(value);
					break;
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			public void WriteInt64(long value)
			{
				ProtoWriter writer = _writer;
				switch (writer.WireType)
				{
				case WireType.Fixed64:
					writer.ImplWriteFixed64(ref this, (ulong)value);
					writer.AdvanceAndReset(8);
					break;
				case WireType.Variant:
					writer.AdvanceAndReset(writer.ImplWriteVarint64(ref this, (ulong)value));
					break;
				case WireType.SignedVariant:
					writer.AdvanceAndReset(writer.ImplWriteVarint64(ref this, Zig(value)));
					break;
				case WireType.Fixed32:
					writer.ImplWriteFixed32(ref this, checked((uint)(int)value));
					writer.AdvanceAndReset(4);
					break;
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			public void WriteUInt64(ulong value)
			{
				ProtoWriter writer = _writer;
				switch (writer.WireType)
				{
				case WireType.Fixed64:
					writer.ImplWriteFixed64(ref this, value);
					writer.AdvanceAndReset(8);
					break;
				case WireType.Variant:
				{
					int count = writer.ImplWriteVarint64(ref this, value);
					writer.AdvanceAndReset(count);
					break;
				}
				case WireType.Fixed32:
					writer.ImplWriteFixed32(ref this, checked((uint)value));
					writer.AdvanceAndReset(4);
					break;
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteMessage<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(SerializerFeatures features, T value, ISerializer<T> serializer = null)
			{
				_writer.WriteMessage(ref this, value, serializer, PrefixStyle.Base128, features.ApplyRecursionCheck());
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteMessage<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(int fieldNumber, SerializerFeatures features, T value, ISerializer<T> serializer = null)
			{
				if (!TypeHelper<T>.CanBeNull || !TypeHelper<T>.ValueChecker.IsNull(value))
				{
					WriteFieldHeader(fieldNumber, features.IsGroup() ? WireType.StartGroup : WireType.String);
					_writer.WriteMessage(ref this, value, serializer, PrefixStyle.Base128, features.ApplyRecursionCheck());
				}
			}

			public void WriteGroup<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(int fieldNumber, SerializerFeatures features, T value, ISerializer<T> serializer = null)
			{
				if (!TypeHelper<T>.CanBeNull || !TypeHelper<T>.ValueChecker.IsNull(value))
				{
					WriteFieldHeader(fieldNumber, WireType.StartGroup);
					_writer.WriteMessage(ref this, value, serializer, PrefixStyle.Base128, features.ApplyRecursionCheck());
				}
			}

			public void WriteAny<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(int fieldNumber, T value, ISerializer<T> serializer = null)
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSerializer<T>(Model);
				}
				WriteAny(fieldNumber, serializer.Features, value, serializer);
			}

			internal static WireType AssertWrappedAndGetWireType(ref SerializerFeatures features, out bool fieldPresence)
			{
				if (features.IsRepeated())
				{
					fieldPresence = false;
					return AssertWrappedAndGetWireType(ref features, SerializerFeatures.OptionWrappedCollection, SerializerFeatures.OptionWrappedCollectionGroup);
				}
				fieldPresence = features.HasAny(SerializerFeatures.OptionWrappedValueFieldPresence);
				return AssertWrappedAndGetWireType(ref features, SerializerFeatures.OptionWrappedValue, SerializerFeatures.OptionWrappedValueGroup);
				static WireType AssertWrappedAndGetWireType(ref SerializerFeatures features, SerializerFeatures demanded, SerializerFeatures group)
				{
					if (!features.HasAny(demanded))
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException(string.Format("{0} called for {1}, but {2} was not specified", "WriteWrapped", features.GetCategory(), demanded));
					}
					features &= ~demanded;
					if (!features.HasAny(group))
					{
						return WireType.String;
					}
					return WireType.StartGroup;
				}
			}

			public void WriteWrapped<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(int fieldNumber, SerializerFeatures features, T value, ISerializer<T> serializer = null)
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSerializer<T>(Model);
				}
				features.InheritFrom(serializer.Features);
				bool fieldPresence;
				WireType wireType = AssertWrappedAndGetWireType(ref features, out fieldPresence);
				bool flag = TypeHelper<T>.CanBeNull && TypeHelper<T>.ValueChecker.IsNull(value);
				if (!(!fieldPresence && flag))
				{
					WriteFieldHeader(fieldNumber, wireType);
					if (!flag && (fieldPresence || TypeHelper<T>.ValueChecker.HasNonTrivialValue(value)))
					{
						GetWriter().WriteWrappedItem(ref this, features, value, serializer);
					}
					else
					{
						GetWriter().WriteEmptyWrappedItem(ref this);
					}
				}
			}

			public void WriteAny<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(int fieldNumber, SerializerFeatures features, T value, ISerializer<T> serializer = null)
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSerializer<T>(Model);
				}
				features.InheritFrom(serializer.Features);
				if (features.HasAny(SerializerFeatures.OptionWrappedValue))
				{
					WriteWrapped(fieldNumber, features, value, serializer);
				}
				else if (!TypeHelper<T>.CanBeNull || !TypeHelper<T>.ValueChecker.IsNull(value))
				{
					switch (features.GetCategory())
					{
					case SerializerFeatures.CategoryRepeated:
						((IRepeatedSerializer<T>)serializer).WriteRepeated(ref this, fieldNumber, features, value);
						break;
					case SerializerFeatures.CategoryMessage:
					case SerializerFeatures.CategoryMessageWrappedAtRoot:
						WriteFieldHeader(fieldNumber, features.GetWireType());
						_writer.WriteMessage(ref this, value, serializer, PrefixStyle.Base128, features.ApplyRecursionCheck());
						break;
					case SerializerFeatures.CategoryScalar:
						WriteFieldHeader(fieldNumber, features.GetWireType());
						serializer.Write(ref this, value);
						break;
					default:
						features.ThrowInvalidCategory();
						break;
					}
				}
			}

			public void WriteSubType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value, ISubTypeSerializer<T> serializer = null) where T : class
			{
				_writer.WriteSubType(ref this, value, serializer ?? TypeModel.GetSubTypeSerializer<T>(Model));
			}

			public void WriteSubType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(int fieldNumber, T value, ISubTypeSerializer<T> serializer = null) where T : class
			{
				WriteFieldHeader(fieldNumber, WireType.String);
				_writer.WriteSubType(ref this, value, serializer ?? TypeModel.GetSubTypeSerializer<T>(Model));
			}

			public void WriteBaseType<T>([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T value, ISubTypeSerializer<T> serializer = null) where T : class
			{
				(serializer ?? TypeModel.GetSubTypeSerializer<T>(Model)).WriteSubType(ref this, value);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public ISerializer<T> GetSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
			{
				return TypeModel.GetSerializer<T>(Model);
			}

			internal long GetPosition()
			{
				return _writer._position64;
			}

			internal ProtoWriter GetWriter()
			{
				return _writer;
			}

			public void WriteBytes(ReadOnlySequence<byte> data)
			{
				ProtoWriter writer = _writer;
				int num = checked((int)data.Length);
				switch (writer.WireType)
				{
				case WireType.Fixed32:
					if (num != 4)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("length");
					}
					writer.ImplWriteBytes(ref this, data);
					writer.AdvanceAndReset(4);
					break;
				case WireType.Fixed64:
					if (num != 8)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("length");
					}
					writer.ImplWriteBytes(ref this, data);
					writer.AdvanceAndReset(8);
					break;
				case WireType.String:
					writer.AdvanceAndReset(writer.ImplWriteVarint32(ref this, (uint)num) + num);
					if (num != 0)
					{
						writer.ImplWriteBytes(ref this, data);
					}
					break;
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteBytes(ArraySegment<byte> data)
			{
				WriteBytes(new ReadOnlyMemory<byte>(data.Array, data.Offset, data.Count));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteBytes(byte[] data)
			{
				WriteBytes(new ReadOnlyMemory<byte>(data));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteBytes<TStorage>(TStorage value, IMemoryConverter<TStorage, byte> converter = null)
			{
				WriteBytes((ReadOnlyMemory<byte>)(converter ?? DefaultMemoryConverter<byte>.GetFor<TStorage>(Model)).GetMemory(in value));
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void WriteBytes(Memory<byte> data)
			{
				WriteBytes((ReadOnlySpan<byte>)data.Span);
			}

			public void WriteBytes(ReadOnlyMemory<byte> data)
			{
				WriteBytes(data.Span);
			}

			public void WriteBytes(ReadOnlySpan<byte> data)
			{
				ProtoWriter writer = _writer;
				int length = data.Length;
				switch (writer.WireType)
				{
				case WireType.Fixed32:
					if (length != 4)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("length");
					}
					writer.ImplWriteBytes(ref this, data);
					writer.AdvanceAndReset(4);
					break;
				case WireType.Fixed64:
					if (length != 8)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("length");
					}
					writer.ImplWriteBytes(ref this, data);
					writer.AdvanceAndReset(8);
					break;
				case WireType.String:
					writer.AdvanceAndReset(writer.ImplWriteVarint32(ref this, (uint)length) + length);
					if (length != 0)
					{
						writer.ImplWriteBytes(ref this, data);
					}
					break;
				default:
					ThrowInvalidSerializationOperation();
					break;
				}
			}

			public long SerializeRoot<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value, ISerializer<T> serializer = null)
			{
				try
				{
					CheckClear();
					if (serializer == null)
					{
						serializer = TypeModel.GetSerializer<T>(Model);
					}
					long position = GetPosition();
					WriteAsRoot(value, serializer);
					CheckClear();
					long position2 = GetPosition();
					return position2 - position;
				}
				catch
				{
					Abandon();
					throw;
				}
			}

			internal void WriteAsRoot<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value, ISerializer<T> serializer)
			{
				SerializerFeatures serializerFeatures = serializer.Features;
				SerializerFeatures category = serializerFeatures.GetCategory();
				if (category == SerializerFeatures.CategoryMessageWrappedAtRoot)
				{
					WriteMessage(1, SerializerFeatures.CategoryRepeated, value, serializer);
				}
				else
				{
					if (TypeHelper<T>.CanBeNull && TypeHelper<T>.ValueChecker.IsNull(value))
					{
						return;
					}
					switch (category)
					{
					case SerializerFeatures.CategoryScalar:
						WriteFieldHeader(1, serializerFeatures.GetWireType());
						serializer.Write(ref this, value);
						break;
					case SerializerFeatures.CategoryMessage:
						serializer.Write(ref this, value);
						break;
					case SerializerFeatures.CategoryRepeated:
						if (Model.OmitsOption(TypeModel.TypeModelOptions.AllowPackedEncodingAtRoot))
						{
							serializerFeatures |= SerializerFeatures.OptionPackedDisabled;
						}
						((IRepeatedSerializer<T>)serializer).WriteRepeated(ref this, 1, serializerFeatures, value);
						break;
					default:
						serializerFeatures.ThrowInvalidCategory();
						break;
					}
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			public void Abandon()
			{
				_writer?.Abandon();
			}

			private void CheckClear()
			{
				_writer?.CheckClear(ref this);
			}

			internal void WritePackedPrefix(int elementCount, WireType wireType)
			{
				if (WireType != WireType.String)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Invalid wire-type: " + WireType);
				}
				if (elementCount < 0)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("elementCount");
				}
				ulong value;
				switch (wireType)
				{
				case WireType.Fixed32:
					value = (ulong)((long)elementCount << 2);
					break;
				case WireType.Fixed64:
					value = (ulong)((long)elementCount << 3);
					break;
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("wireType", "Invalid wire-type: " + wireType);
					value = 0uL;
					break;
				}
				int count = _writer.ImplWriteVarint64(ref this, value);
				_writer.AdvanceAndReset(count);
			}

			internal void WriteObject(object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int fieldNumber)
			{
				TypeModel model = Model;
				if (model == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Cannot serialize sub-objects unless a model is provided");
				}
				if ((object)type == null)
				{
					type = value.GetType();
				}
				if (WireType != WireType.None)
				{
					ThrowInvalidSerializationOperation();
				}
				switch (style)
				{
				case PrefixStyle.Base128:
					WireType = WireType.String;
					FieldNumber = fieldNumber;
					if (fieldNumber > 0)
					{
						WriteHeaderCore(fieldNumber, WireType.String);
					}
					break;
				case PrefixStyle.Fixed32:
				case PrefixStyle.Fixed32BigEndian:
					FieldNumber = 0;
					WireType = WireType.Fixed32;
					break;
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("style");
					break;
				}
				SubItemToken token = StartSubItem(value, style);
				if (!DynamicStub.TrySerializeAny(1, SerializerFeatures.CategoryMessageWrappedAtRoot, type, Model, ref this, value))
				{
					TypeModel.ThrowUnexpectedType(value.GetType(), Model);
				}
				EndSubItem(token, style);
			}

			internal void WriteHeaderCore(int fieldNumber, WireType wireType)
			{
				uint value = (uint)(fieldNumber << 3) | (uint)(wireType & (WireType)7);
				int num = _writer.ImplWriteVarint32(ref this, value);
				_writer.Advance(num);
			}

			[Obsolete("If possible, please use the WriteMessage API; this API may not work correctly with all writers", false)]
			public SubItemToken StartSubItem(object instance)
			{
				return StartSubItem(instance, PrefixStyle.Base128);
			}

			public void Dispose()
			{
				ProtoWriter writer = _writer;
				this = default(State);
				writer?.Dispose();
			}

			[Obsolete("If possible, please use the WriteMessage API; this API may not work correctly with all writers", false)]
			internal SubItemToken StartSubItem(object instance, PrefixStyle style)
			{
				_writer.PreSubItem(ref this, instance);
				switch (WireType)
				{
				case WireType.StartGroup:
					WireType = WireType.None;
					return new SubItemToken(-FieldNumber);
				case WireType.Fixed32:
					if ((uint)(style - 2) > 1u)
					{
						ThrowInvalidSerializationOperation();
						return default(SubItemToken);
					}
					goto case WireType.String;
				case WireType.String:
					return _writer.ImplStartLengthPrefixedSubItem(ref this, instance, style);
				default:
					ThrowInvalidSerializationOperation();
					return default(SubItemToken);
				}
			}

			[Obsolete("If possible, please use the WriteMessage API; this API may not work correctly with all writers", false)]
			internal void EndSubItem(SubItemToken token, PrefixStyle style)
			{
				_writer.PostSubItem(ref this);
				int num = (int)token.value64;
				if (num < 0)
				{
					WriteHeaderCore(-num, WireType.EndGroup);
					WireType = WireType.None;
				}
				else
				{
					_writer.ImplEndLengthPrefixedSubItem(ref this, token, style);
				}
			}

			public void Close()
			{
				CheckClear();
				_writer?.Cleanup();
			}

			[Obsolete("If possible, please use the WriteMessage API; this API may not work correctly with all writers", false)]
			public void EndSubItem(SubItemToken token)
			{
				EndSubItem(token, PrefixStyle.Base128);
			}

			public void AppendExtensionData(IExtensible instance)
			{
				if (instance == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("instance");
				}
				if (WireType != WireType.None)
				{
					ThrowInvalidSerializationOperation();
				}
				AppendExtensionDataImpl(instance.GetExtensionObject(createIfMissing: false));
			}

			private void AppendExtensionDataImpl(IExtension extn)
			{
				if (extn == null)
				{
					return;
				}
				Stream stream = extn.BeginQuery();
				try
				{
					if (ProtoReader.TryConsumeSegmentRespectingPosition(stream, out var data, -1L))
					{
						_writer.ImplWriteBytes(ref this, new ReadOnlySpan<byte>(data.Array, data.Offset, data.Count));
						_writer.Advance(data.Count);
					}
					else
					{
						_writer.ImplCopyRawFromStream(ref this, stream);
					}
				}
				finally
				{
					extn.EndQuery(stream);
				}
			}

			public void AppendExtensionData(ITypedExtensible instance, Type type)
			{
				if (instance == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("instance");
				}
				if (WireType != WireType.None)
				{
					ThrowInvalidSerializationOperation();
				}
				AppendExtensionDataImpl(instance.GetExtensionObject(type, createIfMissing: false));
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowInvalidSerializationOperation()
			{
				if (_writer == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowProtoException("No underlying writer");
				}
				ProtoBuf.Internal.ThrowHelper.ThrowProtoException($"Invalid serialization operation with wire-type {WireType} at position {GetPosition()}, depth {Depth}");
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal void ThrowTooDeep(int depth)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Maximum model depth exceeded (see TypeModel.MaxDepth): " + depth);
			}

			public void SetPackedField(int fieldNumber)
			{
				if (fieldNumber <= 0)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("fieldNumber");
				}
				_writer.packedFieldNumber = fieldNumber;
			}

			public void ClearPackedField(int fieldNumber)
			{
				if (fieldNumber != _writer.packedFieldNumber)
				{
					ThrowWrongPackedField(fieldNumber, _writer);
				}
				_writer.packedFieldNumber = 0;
				static void ThrowWrongPackedField(int fieldNumber, ProtoWriter writer)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Field mismatch during packed encoding; expected " + writer.packedFieldNumber + " but received " + fieldNumber);
				}
			}

			public void ThrowEnumException(object enumValue)
			{
				string arg = ((enumValue == null) ? "<null>" : (enumValue.GetType().FullName + "." + enumValue.ToString()));
				ProtoBuf.Internal.ThrowHelper.ThrowProtoException($"No wire-value is mapped to the enum {arg} at position {GetPosition()}");
			}

			public static State Create(Stream dest, TypeModel model, object userState = null)
			{
				StreamProtoWriter writer = StreamProtoWriter.CreateStreamProtoWriter(dest, model, userState);
				return new State(writer);
			}
		}

		private sealed class BufferWriterProtoWriter : ProtoWriter
		{
			private IBufferWriter<byte> _writer;

			private readonly NullProtoWriter _nullWriter;

			private protected override bool ImplDemandFlushOnDispose => true;

			internal static State CreateBufferWriterProtoWriter(IBufferWriter<byte> writer, TypeModel model, object userState)
			{
				if (writer == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("writer");
				}
				BufferWriterProtoWriter bufferWriterProtoWriter = Pool<BufferWriterProtoWriter>.TryGet() ?? new BufferWriterProtoWriter();
				bufferWriterProtoWriter.Init(model, userState, impactCount: true);
				bufferWriterProtoWriter._writer = writer;
				return new State(bufferWriterProtoWriter);
			}

			internal override void Init(TypeModel model, object userState, bool impactCount)
			{
				base.Init(model, userState, impactCount);
				_nullWriter.Init(model, userState, impactCount: false);
			}

			private BufferWriterProtoWriter()
			{
				_nullWriter = new NullProtoWriter(netCache);
			}

			private protected override void ClearKnownObjects()
			{
			}

			internal override void Dispose()
			{
				base.Dispose();
				Pool<BufferWriterProtoWriter>.Put(this);
			}

			private protected override void Cleanup()
			{
				base.Cleanup();
				_nullWriter.Cleanup();
				_writer = null;
			}

			protected internal override State DefaultState()
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("You must retain and pass the state from ProtoWriter.CreateForBufferWriter");
				return default(State);
			}

			private protected override bool TryFlush(ref State state)
			{
				if (state.IsActive)
				{
					int num = 0;
					try
					{
						num = state.ConsiderWritten();
						_writer.Advance(num);
					}
					catch (Exception ex)
					{
						ex.Data?.Add("ProtoBuf.Position", _position64);
						ex.Data?.Add("ProtoBuf.Flushing", num);
						throw;
					}
				}
				return true;
			}

			private protected override void ImplWriteFixed32(ref State state, uint value)
			{
				if (state.RemainingInCurrent < 4)
				{
					GetBuffer(ref state);
				}
				state.LocalWriteFixed32(value);
			}

			private protected override void ImplWriteFixed64(ref State state, ulong value)
			{
				if (state.RemainingInCurrent < 8)
				{
					GetBuffer(ref state);
				}
				state.LocalWriteFixed64(value);
			}

			private protected override void ImplWriteString(ref State state, string value, int expectedBytes)
			{
				if (expectedBytes <= state.RemainingInCurrent)
				{
					state.LocalWriteString(value);
				}
				else
				{
					FallbackWriteString(ref state, value, expectedBytes);
				}
			}

			private void FallbackWriteString(ref State state, string value, int expectedBytes)
			{
				GetBuffer(ref state);
				if (expectedBytes <= state.RemainingInCurrent)
				{
					state.LocalWriteString(value);
					return;
				}
				byte[] array = ArrayPool<byte>.Shared.Rent(expectedBytes);
				try
				{
					UTF8.GetBytes(value, 0, value.Length, array, 0);
					FallbackWriteBytes(ref state, new ReadOnlySpan<byte>(array, 0, expectedBytes));
				}
				finally
				{
					ArrayPool<byte>.Shared.Return(array);
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private void GetBuffer(ref State state)
			{
				TryFlush(ref state);
				state.Init(_writer.GetMemory((model == null) ? 1024 : model.BufferSize));
			}

			private protected override void ImplWriteBytes(ref State state, ReadOnlySpan<byte> bytes)
			{
				if (bytes.Length <= state.RemainingInCurrent)
				{
					state.LocalWriteBytes(bytes);
				}
				else
				{
					FallbackWriteBytes(ref state, bytes);
				}
			}

			private protected override void ImplWriteBytes(ref State state, ReadOnlySequence<byte> data)
			{
				if (data.IsSingleSegment)
				{
					ReadOnlySpan<byte> span = data.First.Span;
					if (span.Length <= state.RemainingInCurrent)
					{
						state.LocalWriteBytes(span);
					}
					else
					{
						FallbackWriteBytes(ref state, span);
					}
					return;
				}
				ReadOnlySequence<byte>.Enumerator enumerator = data.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ReadOnlySpan<byte> span2 = enumerator.Current.Span;
					if (span2.Length <= state.RemainingInCurrent)
					{
						state.LocalWriteBytes(span2);
					}
					else
					{
						FallbackWriteBytes(ref state, span2);
					}
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			private void FallbackWriteBytes(ref State state, ReadOnlySpan<byte> span)
			{
				while (true)
				{
					GetBuffer(ref state);
					int remainingInCurrent = state.RemainingInCurrent;
					if (span.Length <= remainingInCurrent)
					{
						break;
					}
					state.LocalWriteBytes(span.Slice(0, remainingInCurrent));
					span = span.Slice(remainingInCurrent);
				}
				state.LocalWriteBytes(span);
			}

			private protected override int ImplWriteVarint32(ref State state, uint value)
			{
				if (state.RemainingInCurrent < 5)
				{
					GetBuffer(ref state);
				}
				return state.LocalWriteVarint32(value);
			}

			internal override int ImplWriteVarint64(ref State state, ulong value)
			{
				if (state.RemainingInCurrent < 10)
				{
					GetBuffer(ref state);
				}
				return state.LocalWriteVarint64(value);
			}

			protected internal override void WriteMessage<T>(ref State state, T value, ISerializer<T> serializer, PrefixStyle style, bool recursionCheck)
			{
				switch (base.WireType)
				{
				case WireType.String:
				case WireType.Fixed32:
					PreSubItem(ref state, (TypeHelper<T>.IsReferenceType && recursionCheck) ? ((object)value) : null);
					WriteWithLengthPrefix(ref state, value, serializer, style);
					PostSubItem(ref state);
					break;
				default:
					base.WriteMessage(ref state, value, serializer, style, recursionCheck);
					break;
				}
			}

			internal override void WriteWrappedItem<T>(ref State state, SerializerFeatures features, T value, ISerializer<T> serializer)
			{
				switch (base.WireType)
				{
				case WireType.String:
				{
					if (serializer == null)
					{
						serializer = TypeModel.GetSerializer<T>(base.Model);
					}
					long num = MeasureAny(_nullWriter, 1, features, value, serializer);
					AdvanceAndReset(ImplWriteVarint64(ref state, (ulong)num));
					if (num != 0L)
					{
						long position = GetPosition(ref state);
						state.WriteAny(1, features, value, serializer);
						long position2 = GetPosition(ref state);
						long num2 = position2 - position;
						if (num2 != num)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Length mismatch; calculated '{num}', actual '{num2}'");
						}
					}
					break;
				}
				case WireType.StartGroup:
					base.WriteWrappedItem(ref state, features, value, serializer);
					break;
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("WireType");
					break;
				}
			}

			internal override void WriteWrappedCollection<TCollection, TItem>(ref State state, SerializerFeatures features, TCollection values, RepeatedSerializer<TCollection, TItem> serializer, ISerializer<TItem> valueSerializer)
			{
				switch (base.WireType)
				{
				case WireType.String:
				{
					if (valueSerializer == null)
					{
						valueSerializer = TypeModel.GetSerializer<TItem>(base.Model);
					}
					long num = MeasureRepeated(_nullWriter, 1, features, values, serializer, valueSerializer);
					AdvanceAndReset(ImplWriteVarint64(ref state, (ulong)num));
					if (num != 0L)
					{
						long position = GetPosition(ref state);
						serializer.WriteRepeated(ref state, 1, features, values, valueSerializer);
						long position2 = GetPosition(ref state);
						long num2 = position2 - position;
						if (num2 != num)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Length mismatch; calculated '{num}', actual '{num2}'");
						}
					}
					break;
				}
				case WireType.StartGroup:
					base.WriteWrappedCollection(ref state, features, values, serializer, valueSerializer);
					break;
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("WireType");
					break;
				}
			}

			internal override void WriteWrappedMap<TCollection, TKey, TValue>(ref State state, SerializerFeatures features, TCollection values, MapSerializer<TCollection, TKey, TValue> serializer, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer, ISerializer<TValue> valueSerializer)
			{
				switch (base.WireType)
				{
				case WireType.String:
				{
					long num = MeasureMap(_nullWriter, 1, features, values, serializer, keyFeatures, valueFeatures, keySerializer, valueSerializer);
					AdvanceAndReset(ImplWriteVarint64(ref state, (ulong)num));
					if (num != 0L)
					{
						long position = GetPosition(ref state);
						serializer.WriteMap(ref state, 1, features, values, keyFeatures, valueFeatures, keySerializer, valueSerializer);
						long position2 = GetPosition(ref state);
						long num2 = position2 - position;
						if (num2 != num)
						{
							ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Length mismatch; calculated '{num}', actual '{num2}'");
						}
					}
					break;
				}
				case WireType.StartGroup:
					base.WriteWrappedMap(ref state, features, values, serializer, keyFeatures, valueFeatures, keySerializer, valueSerializer);
					break;
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("WireType");
					break;
				}
			}

			protected internal override void WriteSubType<T>(ref State state, T value, ISubTypeSerializer<T> serializer)
			{
				switch (base.WireType)
				{
				case WireType.String:
				case WireType.Fixed32:
					WriteWithLengthPrefix(ref state, value, serializer);
					break;
				default:
					base.WriteSubType(ref state, value, serializer);
					break;
				}
			}

			private void WriteWithLengthPrefix<T>(ref State state, T value, ISerializer<T> serializer, PrefixStyle style)
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSerializer<T>(base.Model);
				}
				long num = Measure(_nullWriter, value, serializer);
				switch (style)
				{
				case PrefixStyle.Base128:
					AdvanceAndReset(ImplWriteVarint64(ref state, (ulong)num));
					break;
				case PrefixStyle.Fixed32:
				case PrefixStyle.Fixed32BigEndian:
					ImplWriteFixed32(ref state, checked((uint)num));
					if (style == PrefixStyle.Fixed32BigEndian)
					{
						state.ReverseLast32();
					}
					AdvanceAndReset(4);
					break;
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowNotImplementedException($"Sub-object prefix style not implemented: {style}");
					break;
				case PrefixStyle.None:
					break;
				}
				if (num != 0L)
				{
					long position = GetPosition(ref state);
					serializer.Write(ref state, value);
					long position2 = GetPosition(ref state);
					long num2 = position2 - position;
					if (num2 != num)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Length mismatch; calculated '{num}', actual '{num2}'");
					}
				}
			}

			private void WriteWithLengthPrefix<T>(ref State state, T value, ISubTypeSerializer<T> serializer) where T : class
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSubTypeSerializer<T>(base.Model);
				}
				long num = Measure(_nullWriter, value, serializer);
				AdvanceAndReset(ImplWriteVarint64(ref state, (ulong)num));
				long position = GetPosition(ref state);
				serializer.WriteSubType(ref state, value);
				long position2 = GetPosition(ref state);
				long num2 = position2 - position;
				if (num2 != num)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"Length mismatch; calculated '{num}', actual '{num2}'");
				}
			}

			private protected override void ImplEndLengthPrefixedSubItem(ref State state, SubItemToken token, PrefixStyle style)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("You must use the WriteMessage API with this writer type");
			}

			private protected override SubItemToken ImplStartLengthPrefixedSubItem(ref State state, object instance, PrefixStyle style)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("You must use the WriteMessage API with this writer type");
				return default(SubItemToken);
			}

			private protected override void ImplCopyRawFromStream(ref State state, Stream source)
			{
				while (true)
				{
					if (state.RemainingInCurrent == 0)
					{
						GetBuffer(ref state);
					}
					int num = state.ReadFrom(source);
					if (num > 0)
					{
						Advance(num);
						continue;
					}
					break;
				}
			}
		}

		[StructLayout(LayoutKind.Auto)]
		internal readonly struct WriteState
		{
			internal readonly long Position;

			internal readonly WireType WireType;

			internal readonly int FieldNumber;

			internal WriteState(long position, int fieldNumber, WireType wireType)
			{
				Position = position;
				FieldNumber = fieldNumber;
				WireType = wireType;
			}
		}

		internal sealed class NullProtoWriter : ProtoWriter
		{
			private long _abortAfter;

			private protected override bool ImplDemandFlushOnDispose => false;

			protected internal override State DefaultState()
			{
				return new State(this);
			}

			internal static State CreateNullProtoWriter(TypeModel model, object userState, long abortAfter)
			{
				NullProtoWriter nullProtoWriter = Pool<NullProtoWriter>.TryGet() ?? new NullProtoWriter();
				nullProtoWriter.Init(model, userState, impactCount: true);
				nullProtoWriter._abortAfter = ((abortAfter < 0) ? long.MaxValue : abortAfter);
				return new State(nullProtoWriter);
			}

			private NullProtoWriter()
			{
			}

			internal NullProtoWriter(NetObjectCache knownObjects)
				: base(knownObjects)
			{
				_abortAfter = long.MaxValue;
			}

			internal override void Dispose()
			{
				base.Dispose();
				Pool<NullProtoWriter>.Put(this);
			}

			private protected override void ImplCopyRawFromStream(ref State state, Stream source)
			{
				byte[] array = ArrayPool<byte>.Shared.Rent(8192);
				try
				{
					while (true)
					{
						int num = source.Read(array, 0, array.Length);
						if (num <= 0)
						{
							break;
						}
						Advance(num);
						CheckOversized(ref state);
					}
				}
				finally
				{
					ArrayPool<byte>.Shared.Return(array);
				}
			}

			[MethodImpl(MethodImplOptions.NoInlining)]
			internal static void CheckOversized(long max, long actual)
			{
				if (max >= 0 && actual > max)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowProtoException($"Length {actual} exceeds constrained size of {max} bytes");
				}
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private void CheckOversized(ref State state)
			{
				long position = state.GetPosition();
				if (position > _abortAfter)
				{
					CheckOversized(_abortAfter, position);
				}
			}

			protected internal override void WriteMessage<T>(ref State state, T value, ISerializer<T> serializer, PrefixStyle style, bool recursionCheck)
			{
				long length = Measure(this, value, serializer ?? TypeModel.GetSerializer<T>(base.Model));
				AdvanceSubMessage(ref state, length, style);
			}

			internal override void WriteWrappedItem<T>(ref State state, SerializerFeatures features, T value, ISerializer<T> serializer)
			{
				long length = MeasureAny(this, 1, features, value, serializer ?? TypeModel.GetSerializer<T>(base.Model));
				AdvanceSubMessage(ref state, length, PrefixStyle.Base128);
			}

			internal override void WriteWrappedCollection<TCollection, TItem>(ref State state, SerializerFeatures features, TCollection values, RepeatedSerializer<TCollection, TItem> serializer, ISerializer<TItem> valueSerializer)
			{
				long length = MeasureRepeated(this, 1, features, values, serializer, valueSerializer ?? TypeModel.GetSerializer<TItem>(base.Model));
				AdvanceSubMessage(ref state, length, PrefixStyle.Base128);
			}

			internal override void WriteWrappedMap<TCollection, TKey, TValue>(ref State state, SerializerFeatures features, TCollection values, MapSerializer<TCollection, TKey, TValue> serializer, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer, ISerializer<TValue> valueSerializer)
			{
				long length = MeasureMap(this, 1, features, values, serializer, keyFeatures, valueFeatures, keySerializer, valueSerializer);
				AdvanceSubMessage(ref state, length, PrefixStyle.Base128);
			}

			private void AdvanceSubMessage(ref State state, long length, PrefixStyle style)
			{
				long num;
				switch (base.WireType)
				{
				case WireType.String:
				case WireType.Fixed32:
					switch (style)
					{
					case PrefixStyle.None:
						num = 0L;
						break;
					case PrefixStyle.Fixed32:
					case PrefixStyle.Fixed32BigEndian:
						num = 4L;
						break;
					case PrefixStyle.Base128:
						num = ImplWriteVarint64(ref state, (ulong)length);
						break;
					default:
						state.ThrowInvalidSerializationOperation();
						num = 0L;
						break;
					}
					break;
				case WireType.StartGroup:
					num = ImplWriteVarint32(ref state, (uint)(fieldNumber << 3));
					break;
				default:
					state.ThrowInvalidSerializationOperation();
					num = 0L;
					break;
				}
				Advance(num + length);
				CheckOversized(ref state);
				base.WireType = WireType.None;
			}

			protected internal override void WriteSubType<T>(ref State state, T value, ISubTypeSerializer<T> serializer)
			{
				if (serializer == null)
				{
					serializer = TypeModel.GetSubTypeSerializer<T>(base.Model);
				}
				long length = Measure(this, value, serializer);
				AdvanceSubMessage(ref state, length, PrefixStyle.Base128);
			}

			private protected override SubItemToken ImplStartLengthPrefixedSubItem(ref State state, object instance, PrefixStyle style)
			{
				base.WireType = WireType.None;
				return new SubItemToken(_position64);
			}

			private protected override void ImplEndLengthPrefixedSubItem(ref State state, SubItemToken token, PrefixStyle style)
			{
				long value = _position64 - token.value64;
				int num;
				switch (style)
				{
				case PrefixStyle.Fixed32:
				case PrefixStyle.Fixed32BigEndian:
					num = 4;
					break;
				case PrefixStyle.Base128:
					num = ImplWriteVarint64(ref state, (ulong)value);
					break;
				default:
					state.ThrowInvalidSerializationOperation();
					goto case PrefixStyle.None;
				case PrefixStyle.None:
					num = 0;
					break;
				}
				Advance(num);
				CheckOversized(ref state);
			}

			private protected override void ImplWriteBytes(ref State state, ReadOnlySpan<byte> data)
			{
			}

			private protected override void ImplWriteBytes(ref State state, ReadOnlySequence<byte> data)
			{
			}

			private protected override void ImplWriteFixed32(ref State state, uint value)
			{
			}

			private protected override void ImplWriteFixed64(ref State state, ulong value)
			{
			}

			private protected override void ImplWriteString(ref State state, string value, int expectedBytes)
			{
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			private protected override int ImplWriteVarint32(ref State state, uint value)
			{
				return MeasureUInt32(value);
			}

			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			internal override int ImplWriteVarint64(ref State state, ulong value)
			{
				return MeasureUInt64(value);
			}

			private protected override bool TryFlush(ref State state)
			{
				return true;
			}
		}

		private class StreamProtoWriter : ProtoWriter
		{
			private Stream dest;

			private int flushLock;

			private byte[] ioBuffer;

			private int ioIndex;

			private protected override bool ImplDemandFlushOnDispose => true;

			protected internal override State DefaultState()
			{
				return new State(this);
			}

			private StreamProtoWriter()
			{
			}

			internal static StreamProtoWriter CreateStreamProtoWriter(Stream dest, TypeModel model, object userState)
			{
				StreamProtoWriter streamProtoWriter = Pool<StreamProtoWriter>.TryGet() ?? new StreamProtoWriter();
				streamProtoWriter.Init(model, userState, impactCount: true);
				if (dest == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("dest");
				}
				if (!dest.CanWrite)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("Cannot write to stream", "dest");
				}
				streamProtoWriter.dest = dest;
				streamProtoWriter.ioBuffer = BufferPool.GetBuffer();
				return streamProtoWriter;
			}

			internal override void Init(TypeModel model, object userState, bool impactCount)
			{
				base.Init(model, userState, impactCount);
				ioIndex = 0;
				flushLock = 0;
			}

			internal override void Dispose()
			{
				base.Dispose();
				Pool<StreamProtoWriter>.Put(this);
			}

			private protected override void Cleanup()
			{
				base.Cleanup();
				dest = null;
				BufferPool.ReleaseBufferToPool(ref ioBuffer);
			}

			private static void IncrementedAndReset(int length, StreamProtoWriter writer)
			{
				writer.ioIndex += length;
				writer.Advance(length);
				writer.WireType = WireType.None;
			}

			private protected override bool TryFlush(ref State state)
			{
				if (flushLock != 0)
				{
					return false;
				}
				if (ioIndex != 0 && dest != null)
				{
					dest.Write(ioBuffer, 0, ioIndex);
					ioIndex = 0;
				}
				return true;
			}

			private static void DemandSpace(int required, StreamProtoWriter writer, ref State state)
			{
				if (writer.ioBuffer.Length - writer.ioIndex < required)
				{
					TryFlushOrResize(required, writer, ref state);
				}
			}

			private static void TryFlushOrResize(int required, StreamProtoWriter writer, ref State state)
			{
				if (!writer.TryFlush(ref state) || writer.ioBuffer.Length - writer.ioIndex < required)
				{
					BufferPool.ResizeAndFlushLeft(ref writer.ioBuffer, required + writer.ioIndex, 0, writer.ioIndex);
				}
			}

			private protected override void ImplWriteBytes(ref State state, ReadOnlySpan<byte> bytes)
			{
				int length = bytes.Length;
				if (flushLock != 0 || length <= ioBuffer.Length)
				{
					DemandSpace(length, this, ref state);
					bytes.CopyTo(new Span<byte>(ioBuffer, ioIndex, length));
					ioIndex += length;
				}
				else
				{
					state.Flush();
					WriteFallback(bytes, dest);
				}
			}

			private static void WriteFallback(ReadOnlySpan<byte> bytes, Stream stream)
			{
				byte[] array = ArrayPool<byte>.Shared.Rent(2048);
				try
				{
					Span<byte> destination = new Span<byte>(array);
					int length = destination.Length;
					while (bytes.Length >= length)
					{
						bytes.Slice(0, length).CopyTo(destination);
						stream.Write(array, 0, length);
						bytes = bytes.Slice(length);
					}
					bytes.CopyTo(destination);
					stream.Write(array, 0, bytes.Length);
				}
				finally
				{
					ArrayPool<byte>.Shared.Return(array);
				}
			}

			private protected override void ImplWriteBytes(ref State state, ReadOnlySequence<byte> data)
			{
				int num = checked((int)data.Length);
				if (num == 0)
				{
					return;
				}
				if (flushLock != 0 || num <= ioBuffer.Length)
				{
					DemandSpace(num, this, ref state);
					data.CopyTo(new Span<byte>(ioBuffer, ioIndex, num));
					ioIndex += num;
					return;
				}
				state.Flush();
				ReadOnlySequence<byte>.Enumerator enumerator = data.GetEnumerator();
				while (enumerator.MoveNext())
				{
					ReadOnlyMemory<byte> current = enumerator.Current;
					if (MemoryMarshal.TryGetArray(current, out var segment))
					{
						dest.Write(segment.Array, segment.Offset, segment.Count);
						continue;
					}
					byte[] array = ArrayPool<byte>.Shared.Rent(current.Length);
					try
					{
						current.CopyTo(array);
						dest.Write(array, 0, current.Length);
					}
					finally
					{
						ArrayPool<byte>.Shared.Return(array);
					}
				}
			}

			private protected override void ImplWriteString(ref State state, string value, int expectedBytes)
			{
				DemandSpace(expectedBytes, this, ref state);
				int bytes = UTF8.GetBytes(value, 0, value.Length, ioBuffer, ioIndex);
				ioIndex += bytes;
			}

			private static void WriteUInt32ToBuffer(uint value, byte[] buffer, int index)
			{
				BinaryPrimitives.WriteUInt32LittleEndian(MemoryExtensions.AsSpan(buffer, index, 4), value);
			}

			private protected override void ImplWriteFixed32(ref State state, uint value)
			{
				DemandSpace(4, this, ref state);
				WriteUInt32ToBuffer(value, ioBuffer, ioIndex);
				ioIndex += 4;
			}

			private protected override void ImplWriteFixed64(ref State state, ulong value)
			{
				DemandSpace(8, this, ref state);
				byte[] array = ioBuffer;
				int start = ioIndex;
				BinaryPrimitives.WriteUInt64LittleEndian(MemoryExtensions.AsSpan(array, start, 8), value);
				ioIndex += 8;
			}

			internal override int ImplWriteVarint64(ref State state, ulong value)
			{
				DemandSpace(10, this, ref state);
				int num = 0;
				do
				{
					ioBuffer[ioIndex++] = (byte)((value & 0x7F) | 0x80);
					num++;
				}
				while ((value >>= 7) != 0L);
				ioBuffer[ioIndex - 1] &= 127;
				return num;
			}

			private protected override int ImplWriteVarint32(ref State state, uint value)
			{
				DemandSpace(5, this, ref state);
				int num = 0;
				do
				{
					ioBuffer[ioIndex++] = (byte)((value & 0x7Fu) | 0x80u);
					num++;
				}
				while ((value >>= 7) != 0);
				ioBuffer[ioIndex - 1] &= 127;
				return num;
			}

			private protected override void ImplCopyRawFromStream(ref State state, Stream source)
			{
				byte[] array = ioBuffer;
				int num = array.Length - ioIndex;
				int num2 = 1;
				while (num > 0 && (num2 = source.Read(array, ioIndex, num)) > 0)
				{
					ioIndex += num2;
					Advance(num2);
					num -= num2;
				}
				if (num2 <= 0)
				{
					return;
				}
				if (flushLock == 0)
				{
					state.Flush();
					while ((num2 = source.Read(array, 0, array.Length)) > 0)
					{
						dest.Write(array, 0, num2);
						Advance(num2);
					}
					return;
				}
				while (true)
				{
					DemandSpace(128, this, ref state);
					if ((num2 = source.Read(ioBuffer, ioIndex, ioBuffer.Length - ioIndex)) > 0)
					{
						Advance(num2);
						ioIndex += num2;
						continue;
					}
					break;
				}
			}

			private protected override SubItemToken ImplStartLengthPrefixedSubItem(ref State state, object instance, PrefixStyle style)
			{
				switch (base.WireType)
				{
				case WireType.String:
					base.WireType = WireType.None;
					DemandSpace(32, this, ref state);
					flushLock++;
					Advance(1L);
					return new SubItemToken(ioIndex++);
				case WireType.Fixed32:
				{
					DemandSpace(32, this, ref state);
					flushLock++;
					SubItemToken result = new SubItemToken(ioIndex);
					IncrementedAndReset(4, this);
					return result;
				}
				default:
					state.ThrowInvalidSerializationOperation();
					return default(SubItemToken);
				}
			}

			private protected override void ImplEndLengthPrefixedSubItem(ref State state, SubItemToken token, PrefixStyle style)
			{
				int num = (int)token.value64;
				switch (style)
				{
				case PrefixStyle.Fixed32:
				{
					int num2 = ioIndex - num - 4;
					WriteUInt32ToBuffer((uint)num2, ioBuffer, num);
					break;
				}
				case PrefixStyle.Fixed32BigEndian:
				{
					int num2 = ioIndex - num - 4;
					byte[] array2 = ioBuffer;
					WriteUInt32ToBuffer((uint)num2, array2, num);
					byte b = array2[num];
					array2[num] = array2[num + 3];
					array2[num + 3] = b;
					b = array2[num + 1];
					array2[num + 1] = array2[num + 2];
					array2[num + 2] = b;
					break;
				}
				case PrefixStyle.Base128:
				{
					int num2 = ioIndex - num - 1;
					int num3 = 0;
					uint num4 = (uint)num2;
					while ((num4 >>= 7) != 0)
					{
						num3++;
					}
					if (num3 == 0)
					{
						ioBuffer[num] = (byte)((uint)num2 & 0x7Fu);
						break;
					}
					DemandSpace(num3, this, ref state);
					byte[] array = ioBuffer;
					Buffer.BlockCopy(array, num + 1, array, num + 1 + num3, num2);
					num4 = (uint)num2;
					do
					{
						array[num++] = (byte)((num4 & 0x7Fu) | 0x80u);
					}
					while ((num4 >>= 7) != 0);
					array[num - 1] = (byte)(array[num - 1] & 0xFFFFFF7Fu);
					Advance(num3);
					ioIndex += num3;
					break;
				}
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("style");
					break;
				}
				if (--flushLock == 0 && ioIndex >= 1024)
				{
					state.Flush();
				}
			}
		}

		private const MethodImplOptions HotPath = MethodImplOptions.AggressiveInlining;

		internal const string PreferWriteMessage = "If possible, please use the WriteMessage API; this API may not work correctly with all writers";

		private TypeModel model;

		private int packedFieldNumber;

		private protected readonly NetObjectCache netCache;

		private int fieldNumber;

		private int _depth;

		private const int RecursionCheckDepth = 25;

		private List<object> recursionStack;

		private bool _needFlush;

		private long _position64;

		protected internal static readonly UTF8Encoding UTF8 = new UTF8Encoding();

		internal WireType WireType { get; set; }

		[Obsolete("Prefer UserState")]
		public SerializationContext Context => SerializationContext.AsSerializationContext(this);

		public object UserState { get; private set; }

		internal int Depth => _depth;

		public TypeModel Model
		{
			get
			{
				return model;
			}
			internal set
			{
				model = value;
			}
		}

		private protected abstract bool ImplDemandFlushOnDispose { get; }

		[Obsolete("Please migrate to TypeModel.BufferSize")]
		public static int BufferSize
		{
			get
			{
				return TypeModel.DefaultModel.BufferSize;
			}
			set
			{
				TypeModel.DefaultModel.BufferSize = value;
			}
		}

		void IDisposable.Dispose()
		{
			Dispose();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteFieldHeader(int fieldNumber, WireType wireType, ProtoWriter writer)
		{
			writer.DefaultState().WriteFieldHeader(fieldNumber, wireType);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteBytes(byte[] data, ProtoWriter writer)
		{
			writer.DefaultState().WriteBytes(data);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteBytes(byte[] data, int offset, int length, ProtoWriter writer)
		{
			writer.DefaultState().WriteBytes(new ReadOnlyMemory<byte>(data, offset, length));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Obsolete("If possible, please use the WriteMessage API; this API may not work correctly with all writers", false)]
		public static SubItemToken StartSubItem(object instance, ProtoWriter writer)
		{
			return writer.DefaultState().StartSubItem(instance, PrefixStyle.Base128);
		}

		private void PreSubItem(ref State state, object instance)
		{
			if (_depth < 0)
			{
				state.ThrowInvalidSerializationOperation();
			}
			if (++_depth >= ((model == null) ? 512 : model.MaxDepth))
			{
				state.ThrowTooDeep(_depth);
			}
			if (_depth > 25)
			{
				CheckRecursionStackAndPush(instance);
			}
			if (packedFieldNumber != 0)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Cannot begin a sub-item while performing packed encoding");
			}
		}

		private void CheckRecursionStackAndPush(object instance)
		{
			if (recursionStack == null)
			{
				recursionStack = new List<object>();
			}
			else if (instance != null)
			{
				int num = 0;
				foreach (object item in recursionStack)
				{
					if (item == instance)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowProtoException($"Possible recursion detected (offset: {recursionStack.Count - num} level(s)): {instance}");
					}
					num++;
				}
			}
			recursionStack.Add(instance);
		}

		private void PopRecursionStack()
		{
			recursionStack.RemoveAt(recursionStack.Count - 1);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		[Obsolete("If possible, please use the WriteMessage API; this API may not work correctly with all writers", false)]
		public static void EndSubItem(SubItemToken token, ProtoWriter writer)
		{
			writer.DefaultState().EndSubItem(token, PrefixStyle.Base128);
		}

		private void PostSubItem(ref State state)
		{
			if (WireType != WireType.None)
			{
				state.ThrowInvalidSerializationOperation();
			}
			if (_depth <= 0)
			{
				state.ThrowInvalidSerializationOperation();
			}
			if (_depth-- > 25)
			{
				PopRecursionStack();
			}
			packedFieldNumber = 0;
		}

		private protected ProtoWriter()
		{
			netCache = new NetObjectCache();
		}

		private protected ProtoWriter(NetObjectCache knownObjects)
		{
			netCache = knownObjects;
		}

		internal virtual void Init(TypeModel model, object userState, bool impactCount)
		{
			_position64 = 0L;
			_needFlush = false;
			packedFieldNumber = 0;
			_depth = 0;
			fieldNumber = 0;
			this.model = model;
			WireType = WireType.None;
			if (userState is SerializationContext serializationContext)
			{
				serializationContext.Freeze();
			}
			UserState = userState;
		}

		internal WriteState ResetWriteState()
		{
			WriteState result = new WriteState(_position64, fieldNumber, WireType);
			_position64 = 0L;
			fieldNumber = 0;
			WireType = WireType.None;
			return result;
		}

		internal void SetWriteState(WriteState state)
		{
			_position64 = state.Position;
			fieldNumber = state.FieldNumber;
			WireType = state.WireType;
		}

		internal virtual void Dispose()
		{
			Cleanup();
		}

		private protected virtual void Cleanup()
		{
			if (_depth == 0 && _needFlush && ImplDemandFlushOnDispose)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Writer was disposed without being flushed; data may be lost - you should ensure that Flush (or Abandon) is called");
			}
			recursionStack?.Clear();
			ClearKnownObjects();
			model = null;
			UserState = null;
		}

		private protected virtual void ClearKnownObjects()
		{
			netCache?.Clear();
		}

		protected internal virtual void WriteMessage<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ref State state, T value, ISerializer<T> serializer, PrefixStyle style, bool recursionCheck)
		{
			SubItemToken token = state.StartSubItem((TypeHelper<T>.IsReferenceType && recursionCheck) ? ((object)value) : null, style);
			(serializer ?? TypeModel.GetSerializer<T>(model)).Write(ref state, value);
			state.EndSubItem(token, style);
		}

		internal virtual void WriteWrappedCollection<TCollection, TItem>(ref State state, SerializerFeatures features, TCollection values, RepeatedSerializer<TCollection, TItem> serializer, ISerializer<TItem> valueSerializer)
		{
			SubItemToken token = state.StartSubItem(null);
			serializer.WriteRepeated(ref state, 1, features, values, valueSerializer);
			state.EndSubItem(token);
		}

		internal virtual void WriteWrappedMap<TCollection, TKey, TValue>(ref State state, SerializerFeatures features, TCollection values, MapSerializer<TCollection, TKey, TValue> serializer, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer, ISerializer<TValue> valueSerializer)
		{
			SubItemToken token = state.StartSubItem(null);
			serializer.WriteMap(ref state, 1, features, values, keyFeatures, valueFeatures, keySerializer, valueSerializer);
			state.EndSubItem(token);
		}

		internal void WriteEmptyWrappedItem(ref State state)
		{
			switch (WireType)
			{
			case WireType.String:
				AdvanceAndReset(ImplWriteVarint32(ref state, 0u));
				break;
			case WireType.StartGroup:
				state.WriteHeaderCore(state.FieldNumber, WireType.EndGroup);
				WireType = WireType.None;
				break;
			default:
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("WireType");
				break;
			}
		}

		internal virtual void WriteWrappedItem<T>(ref State state, SerializerFeatures features, T value, ISerializer<T> serializer)
		{
			SubItemToken token = state.StartSubItem((TypeHelper<T>.IsReferenceType & features.ApplyRecursionCheck()) ? ((object)value) : null, PrefixStyle.Base128);
			state.WriteAny(1, features, value, serializer);
			state.EndSubItem(token);
		}

		protected internal virtual void WriteSubType<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ref State state, T value, ISubTypeSerializer<T> serializer) where T : class
		{
			SubItemToken token = state.StartSubItem(null, PrefixStyle.Base128);
			serializer.WriteSubType(ref state, value);
			state.EndSubItem(token, PrefixStyle.Base128);
		}

		public void Abandon()
		{
			_needFlush = false;
		}

		internal long GetPosition(ref State state)
		{
			return _position64;
		}

		private protected void Advance(long count)
		{
			_position64 += count;
		}

		internal void AdvanceAndReset(int count)
		{
			_position64 += count;
			WireType = WireType.None;
		}

		internal void AdvanceAndReset(long count)
		{
			_position64 += count;
			WireType = WireType.None;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Close()
		{
			DefaultState().Close();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal void CheckClear(ref State state)
		{
			if (_depth != 0 || !TryFlush(ref state))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"The writer is in an incomplete state (depth: {_depth}, type: {GetType().Name}, field: {fieldNumber}, wire-type: {WireType}, position: {state.GetPosition()})");
			}
			_needFlush = false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static uint Zig(int value)
		{
			return (uint)((value << 1) ^ (value >> 31));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ulong Zig(long value)
		{
			return (ulong)((value << 1) ^ (value >> 63));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteString(string value, ProtoWriter writer)
		{
			writer.DefaultState().WriteString(value);
		}

		private protected abstract void ImplWriteString(ref State state, string value, int expectedBytes);

		private protected abstract int ImplWriteVarint32(ref State state, uint value);

		internal abstract int ImplWriteVarint64(ref State state, ulong value);

		private protected abstract void ImplWriteFixed32(ref State state, uint value);

		private protected abstract void ImplWriteFixed64(ref State state, ulong value);

		private protected abstract void ImplWriteBytes(ref State state, ReadOnlySpan<byte> data);

		private protected abstract void ImplWriteBytes(ref State state, ReadOnlySequence<byte> data);

		private protected abstract void ImplCopyRawFromStream(ref State state, Stream source);

		private protected abstract SubItemToken ImplStartLengthPrefixedSubItem(ref State state, object instance, PrefixStyle style);

		private protected abstract void ImplEndLengthPrefixedSubItem(ref State state, SubItemToken token, PrefixStyle style);

		private protected abstract bool TryFlush(ref State state);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteUInt64(ulong value, ProtoWriter writer)
		{
			writer.DefaultState().WriteUInt64(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt64(long value, ProtoWriter writer)
		{
			writer.DefaultState().WriteInt64(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteUInt32(uint value, ProtoWriter writer)
		{
			writer.DefaultState().WriteUInt32(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteInt16(short value, ProtoWriter writer)
		{
			writer.DefaultState().WriteInt16(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteUInt16(ushort value, ProtoWriter writer)
		{
			writer.DefaultState().WriteUInt16(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteByte(byte value, ProtoWriter writer)
		{
			writer.DefaultState().WriteByte(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteSByte(sbyte value, ProtoWriter writer)
		{
			writer.DefaultState().WriteSByte(value);
		}

		public static void WriteInt32(int value, ProtoWriter writer)
		{
			writer.DefaultState().WriteInt32(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteDouble(double value, ProtoWriter writer)
		{
			writer.DefaultState().WriteDouble(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteSingle(float value, ProtoWriter writer)
		{
			writer.DefaultState().WriteSingle(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ThrowEnumException(ProtoWriter writer, object enumValue)
		{
			writer.DefaultState().ThrowEnumException(enumValue);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteBoolean(bool value, ProtoWriter writer)
		{
			writer.DefaultState().WriteBoolean(value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void AppendExtensionData(IExtensible instance, ProtoWriter writer)
		{
			writer.DefaultState().AppendExtensionData(instance);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void SetPackedField(int fieldNumber, ProtoWriter writer)
		{
			writer.DefaultState().SetPackedField(fieldNumber);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ClearPackedField(int fieldNumber, ProtoWriter writer)
		{
			writer.DefaultState().ClearPackedField(fieldNumber);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WritePackedPrefix(int elementCount, WireType wireType, ProtoWriter writer)
		{
			writer.DefaultState().WritePackedPrefix(elementCount, wireType);
		}

		internal string SerializeType(Type type)
		{
			return TypeModel.SerializeType(model, type);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void WriteType(Type value, ProtoWriter writer)
		{
			writer.DefaultState().WriteType(value);
		}

		internal static long MeasureRepeated<TCollection, TItem>(NullProtoWriter writer, int fieldNumber, SerializerFeatures features, TCollection values, RepeatedSerializer<TCollection, TItem> serializer, ISerializer<TItem> valueSerializer)
		{
			object obj = null;
			long length;
			if (TypeHelper<TCollection>.IsReferenceType)
			{
				obj = values;
				if (obj == null)
				{
					return 0L;
				}
				if (writer.netCache.TryGetKnownLength(obj, null, out length))
				{
					return length;
				}
			}
			WriteState writeState = writer.ResetWriteState();
			State state = new State(writer);
			serializer.WriteRepeated(ref state, fieldNumber, features, values, valueSerializer);
			length = state.GetPosition();
			writer.SetWriteState(writeState);
			if (obj != null)
			{
				writer.netCache.SetKnownLength(obj, null, length);
			}
			return length;
		}

		internal static long MeasureMap<TCollection, TKey, TValue>(NullProtoWriter writer, int fieldNumber, SerializerFeatures features, TCollection values, MapSerializer<TCollection, TKey, TValue> serializer, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer, ISerializer<TValue> valueSerializer)
		{
			object obj = null;
			long length;
			if (TypeHelper<TCollection>.IsReferenceType)
			{
				obj = values;
				if (obj == null)
				{
					return 0L;
				}
				if (writer.netCache.TryGetKnownLength(obj, null, out length))
				{
					return length;
				}
			}
			WriteState writeState = writer.ResetWriteState();
			State state = new State(writer);
			serializer.WriteMap(ref state, fieldNumber, features, values, keyFeatures, valueFeatures, keySerializer, valueSerializer);
			length = state.GetPosition();
			writer.SetWriteState(writeState);
			if (obj != null)
			{
				writer.netCache.SetKnownLength(obj, null, length);
			}
			return length;
		}

		internal static long MeasureAny<T>(NullProtoWriter writer, int fieldNumber, SerializerFeatures features, T value, ISerializer<T> serializer)
		{
			WriteState writeState = writer.ResetWriteState();
			State state = new State(writer);
			state.WriteAny(fieldNumber, features, value, serializer);
			long position = state.GetPosition();
			writer.SetWriteState(writeState);
			return position;
		}

		internal static long Measure<T>(NullProtoWriter writer, T value, ISerializer<T> serializer)
		{
			object obj = null;
			long length;
			if (TypeHelper<T>.IsReferenceType)
			{
				obj = value;
				if (obj == null)
				{
					return 0L;
				}
				if (writer.netCache.TryGetKnownLength(obj, null, out length))
				{
					return length;
				}
			}
			WriteState writeState = writer.ResetWriteState();
			State state = new State(writer);
			serializer.Write(ref state, value);
			length = state.GetPosition();
			writer.SetWriteState(writeState);
			if (obj != null)
			{
				writer.netCache.SetKnownLength(obj, null, length);
			}
			return length;
		}

		internal static long Measure<T>(NullProtoWriter writer, T value, ISubTypeSerializer<T> serializer) where T : class
		{
			if (value == null)
			{
				return 0L;
			}
			if (writer.netCache.TryGetKnownLength(value, typeof(T), out var length))
			{
				return length;
			}
			WriteState writeState = writer.ResetWriteState();
			State state = new State(writer);
			serializer.WriteSubType(ref state, value);
			length = state.GetPosition();
			writer.SetWriteState(writeState);
			writer.netCache.SetKnownLength(value, typeof(T), length);
			return length;
		}

		internal static State CreateNull(TypeModel model, object userState, long abortAfter)
		{
			return NullProtoWriter.CreateNullProtoWriter(model, userState, abortAfter);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int MeasureUInt32(uint value)
		{
			int num = 1;
			while ((value >>= 7) != 0)
			{
				num++;
			}
			return num;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static int MeasureUInt64(ulong value)
		{
			int num = 1;
			while ((value >>= 7) != 0L)
			{
				num++;
			}
			return num;
		}

		protected internal abstract State DefaultState();

		internal void InitializeFrom(ProtoWriter writer)
		{
			netCache?.InitializeFrom(writer?.netCache);
		}

		internal void CopyBack(ProtoWriter writer)
		{
			netCache?.CopyBack(writer?.netCache);
		}

		internal int GetLengthHits(out int misses)
		{
			misses = netCache?.LengthMisses ?? 0;
			return netCache?.LengthHits ?? 0;
		}

		[Obsolete("If possible, please use the State API; a transitionary implementation is provided, but this API may be removed in a future version", false)]
		public static ProtoWriter Create(Stream dest, TypeModel model, SerializationContext context = null)
		{
			return StreamProtoWriter.CreateStreamProtoWriter(dest, model, context);
		}
	}
	internal sealed class SerializationContext
	{
		private bool frozen;

		private object context;

		private StreamingContextStates state = StreamingContextStates.Persistence;

		public object Context
		{
			get
			{
				return context;
			}
			set
			{
				if (context != value)
				{
					ThrowIfFrozen();
					context = value;
				}
			}
		}

		internal static SerializationContext Default { get; } = new SerializationContext
		{
			frozen = true
		};


		public StreamingContextStates State
		{
			get
			{
				return state;
			}
			set
			{
				if (state != value)
				{
					ThrowIfFrozen();
					state = value;
				}
			}
		}

		internal void Freeze()
		{
			frozen = true;
		}

		private void ThrowIfFrozen()
		{
			if (frozen)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The serialization-context cannot be changed once it is in use");
			}
		}

		public static implicit operator StreamingContext(SerializationContext ctx)
		{
			if (ctx == null)
			{
				return new StreamingContext(StreamingContextStates.Persistence);
			}
			return new StreamingContext(ctx.state, ctx.context);
		}

		public static implicit operator SerializationContext(StreamingContext ctx)
		{
			return new SerializationContext
			{
				Context = ctx.Context,
				State = ctx.State
			};
		}

		public static StreamingContext AsStreamingContext(ISerializationContext context)
		{
			object obj = context?.UserState;
			if (obj is SerializationContext serializationContext)
			{
				return new StreamingContext(serializationContext.state, serializationContext.context);
			}
			return new StreamingContext(StreamingContextStates.Persistence, obj);
		}

		public static SerializationContext AsSerializationContext(ISerializationContext context)
		{
			object obj = context?.UserState;
			if (obj != null)
			{
				if (obj is SerializationContext result)
				{
					return result;
				}
				return new SerializationContext
				{
					context = context,
					frozen = true
				};
			}
			return Default;
		}
	}
	internal sealed class StringMap
	{
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct SubItemToken
	{
		internal readonly long value64;

		public override string ToString()
		{
			if (value64 < 0)
			{
				return $"Group {-value64}";
			}
			if (value64 == long.MaxValue)
			{
				return "Message (restores to end when ended)";
			}
			return "Message (restores to value64 when ended)";
		}

		public override int GetHashCode()
		{
			long num = value64;
			return num.GetHashCode();
		}

		public override bool Equals(object obj)
		{
			if (obj is SubItemToken subItemToken)
			{
				return subItemToken.value64 == value64;
			}
			return false;
		}

		internal SubItemToken(long value)
		{
			value64 = value;
		}
	}
	internal static class TypedExtensible
	{
		public static bool TryGetValue<TValue>(this ITypedExtensible instance, int tag, out TValue value, Type type = null, DataFormat format = DataFormat.Default, TypeModel model = null)
		{
			IExtension extension = GetExtension(instance, type, createIfMissing: false, ref model);
			value = default(TValue);
			bool result = false;
			if (extension != null)
			{
				foreach (TValue extendedValue in ExtensibleUtil.GetExtendedValues(model, typeof(TValue), extension, tag, format, singleton: true))
				{
					value = extendedValue;
					result = true;
				}
			}
			return result;
		}

		public static TValue GetValue<TValue>(this ITypedExtensible instance, int tag, Type type = null, DataFormat format = DataFormat.Default, TypeModel model = null)
		{
			if (!instance.TryGetValue<TValue>(tag, out var value, type, format, model))
			{
				return default(TValue);
			}
			return value;
		}

		public static IEnumerable<TValue> GetValues<TValue>(this ITypedExtensible instance, int tag, Type type = null, DataFormat format = DataFormat.Default, TypeModel model = null)
		{
			IExtension extension = GetExtension(instance, type, createIfMissing: false, ref model);
			if (extension != null)
			{
				return ExtensibleUtil.GetExtendedValues(model, typeof(TValue), extension, tag, format, singleton: false).Cast<TValue>();
			}
			return Enumerable.Empty<TValue>();
		}

		public static void AppendValue<TValue>(this ITypedExtensible instance, int tag, TValue value, Type type = null, DataFormat format = DataFormat.Default, TypeModel model = null)
		{
			object obj = value;
			if (obj == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("value");
			}
			ExtensibleUtil.AppendExtendValue(model, GetExtension(instance, type, createIfMissing: true, ref model), tag, format, obj);
		}

		private static IExtension GetExtension(ITypedExtensible instance, Type type, bool createIfMissing, ref TypeModel model)
		{
			if (instance == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("instance");
			}
			Type type2 = instance.GetType();
			if ((object)type == null)
			{
				type = type2;
			}
			if (!type.IsClass)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("Extension fields can only be used with class target types ('" + type.NormalizeName() + "' is not valid)");
			}
			if ((object)type != type2)
			{
				if (model == null)
				{
					model = TypeModel.DefaultModel;
				}
				if (type == typeof(object) || type == typeof(Extensible) || !type.IsAssignableFrom(type2) || (!(model is TypeModel.NullModel) && !model.CanSerializeContractType(type)))
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The extension field target type '" + type.NormalizeName() + "' is not a valid base-type of '" + type2.NormalizeName() + "'");
				}
			}
			return instance.GetExtensionObject(type, createIfMissing);
		}
	}
	internal delegate Type TypeResolver(int fieldNumber);
	internal enum WireType
	{
		None = -1,
		[Obsolete("This is an embarrassing typo... sorry; see also: Varint")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		[Browsable(false)]
		Variant = 0,
		Varint = 0,
		Fixed64 = 1,
		String = 2,
		StartGroup = 3,
		EndGroup = 4,
		Fixed32 = 5,
		[Browsable(false)]
		[Obsolete("This is an embarrassing typo... sorry; see also: SignedVarint")]
		[EditorBrowsable(EditorBrowsableState.Never)]
		SignedVariant = 8,
		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		SignedVarint = 8
	}
}
namespace ProtoBuf.WellKnownTypes
{
	[StructLayout(LayoutKind.Auto)]
	[ProtoContract(Name = ".google.protobuf.Duration", Serializer = typeof(PrimaryTypeProvider), Origin = "google/protobuf/duration.proto")]
	internal readonly struct Duration
	{
		[ProtoMember(1, Name = "seconds", DataFormat = DataFormat.Default)]
		public long Seconds { get; }

		[ProtoMember(2, Name = "nanos", DataFormat = DataFormat.Default)]
		public int Nanoseconds { get; }

		public Duration(long seconds, int nanoseconds)
		{
			Seconds = seconds;
			Nanoseconds = nanoseconds;
		}

		public Duration(TimeSpan value)
		{
			Seconds = PrimaryTypeProvider.ToDurationSeconds(value, out var nanos, isTimestamp: false);
			Nanoseconds = nanos;
		}

		public TimeSpan AsTimeSpan()
		{
			return TimeSpan.FromTicks(PrimaryTypeProvider.ToTicks(Seconds, Nanoseconds));
		}

		public static implicit operator TimeSpan(Duration value)
		{
			return value.AsTimeSpan();
		}

		public static implicit operator Duration(TimeSpan value)
		{
			return new Duration(value);
		}

		public Duration Normalize()
		{
			long seconds = Seconds;
			int nanos = Nanoseconds;
			PrimaryTypeProvider.NormalizeSecondsNanoseconds(ref seconds, ref nanos, isTimestamp: false);
			return new Duration(seconds, nanos);
		}
	}
	[StructLayout(LayoutKind.Explicit, Size = 1)]
	[ProtoContract(Name = ".google.protobuf.Empty", Serializer = typeof(PrimaryTypeProvider), Origin = "google/protobuf/empty.proto")]
	internal readonly struct Empty
	{
	}
	[StructLayout(LayoutKind.Auto)]
	[ProtoContract(Name = ".google.protobuf.Timestamp", Serializer = typeof(PrimaryTypeProvider), Origin = "google/protobuf/timestamp.proto")]
	internal readonly struct Timestamp
	{
		private static readonly DateTime TimestampEpoch = new DateTime(1970, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);

		[ProtoMember(1, Name = "seconds", DataFormat = DataFormat.Default)]
		public long Seconds { get; }

		[ProtoMember(2, Name = "nanos", DataFormat = DataFormat.Default)]
		public int Nanoseconds { get; }

		public Timestamp(long seconds, int nanoseconds)
		{
			Seconds = seconds;
			Nanoseconds = nanoseconds;
		}

		public Timestamp(DateTime value)
		{
			Seconds = PrimaryTypeProvider.ToDurationSeconds(value - TimestampEpoch, out var nanos, isTimestamp: true);
			Nanoseconds = nanos;
		}

		public Timestamp Normalize()
		{
			long seconds = Seconds;
			int nanos = Nanoseconds;
			PrimaryTypeProvider.NormalizeSecondsNanoseconds(ref seconds, ref nanos, isTimestamp: true);
			return new Timestamp(seconds, nanos);
		}

		public DateTime AsDateTime()
		{
			DateTime timestampEpoch = TimestampEpoch;
			return timestampEpoch.AddTicks(PrimaryTypeProvider.ToTicks(Seconds, Nanoseconds));
		}

		public static implicit operator DateTime(Timestamp value)
		{
			return value.AsDateTime();
		}

		public static implicit operator Timestamp(DateTime value)
		{
			return new Timestamp(value);
		}
	}
}
namespace ProtoBuf.Serializers
{
	internal static class EnumSerializer
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateSByte<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerSByte<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateInt16<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerInt16<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateInt32<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerInt32<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateInt64<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerInt64<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateByte<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerByte<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateUInt16<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerUInt16<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateUInt32<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerUInt32<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static EnumSerializer<T> CreateUInt64<T>() where T : unmanaged
		{
			return SerializerCache<EnumSerializerUInt64<T>>.InstanceField;
		}
	}
	internal abstract class EnumSerializer<TEnum> : ISerializer<TEnum>, ISerializer<TEnum?> where TEnum : unmanaged
	{
		SerializerFeatures ISerializer<TEnum>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<TEnum?>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		TEnum? ISerializer<TEnum?>.Read(ref ProtoReader.State state, TEnum? value)
		{
			return Read(ref state, default(TEnum));
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		void ISerializer<TEnum?>.Write(ref ProtoWriter.State state, TEnum? value)
		{
			Write(ref state, value.Value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public abstract TEnum Read(ref ProtoReader.State state, TEnum value);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public abstract void Write(ref ProtoWriter.State state, TEnum value);

		private protected EnumSerializer()
		{
		}
	}
	internal abstract class EnumSerializer<TEnum, TRaw> : EnumSerializer<TEnum>, IMeasuringSerializer<TEnum>, ISerializer<TEnum>, IMeasuringSerializer<TEnum?>, ISerializer<TEnum?> where TEnum : unmanaged where TRaw : unmanaged
	{
		private protected const int NegLength = 10;

		private protected unsafe EnumSerializer()
		{
			Type typeFromHandle = typeof(TEnum);
			if (sizeof(TEnum) != sizeof(TRaw) || !typeFromHandle.IsEnum || Enum.GetUnderlyingType(typeFromHandle) != typeof(TRaw))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException(typeof(TEnum).NormalizeName() + " is not a valid enum for " + typeof(TRaw).NormalizeName());
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected abstract TRaw Read(ref ProtoReader.State state);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected abstract void Write(ref ProtoWriter.State state, TRaw value);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public abstract int MeasureVarint(TRaw value);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public virtual int MeasureSignedVarint(TRaw value)
		{
			return -1;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe override TEnum Read(ref ProtoReader.State state, TEnum value)
		{
			TRaw val = Read(ref state);
			return *(TEnum*)(&val);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public unsafe override void Write(ref ProtoWriter.State state, TEnum value)
		{
			Write(ref state, *(TRaw*)(&value));
		}

		public unsafe int Measure(ISerializationContext context, WireType wireType, TEnum value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => MeasureVarint(*(TRaw*)(&value)), 
				WireType.SignedVariant => MeasureSignedVarint(*(TRaw*)(&value)), 
				_ => -1, 
			};
		}

		int IMeasuringSerializer<TEnum?>.Measure(ISerializationContext context, WireType wireType, TEnum? value)
		{
			return Measure(context, wireType, value.Value);
		}
	}
	internal sealed class EnumSerializerSByte<T> : EnumSerializer<T, sbyte> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override sbyte Read(ref ProtoReader.State state)
		{
			return state.ReadSByte();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, sbyte value)
		{
			state.WriteSByte(value);
		}

		public override int MeasureVarint(sbyte value)
		{
			if (value >= 0)
			{
				return ProtoWriter.MeasureUInt32((uint)value);
			}
			return 10;
		}

		public override int MeasureSignedVarint(sbyte value)
		{
			return ProtoWriter.MeasureUInt32(ProtoWriter.Zig(value));
		}
	}
	internal sealed class EnumSerializerInt16<T> : EnumSerializer<T, short> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override short Read(ref ProtoReader.State state)
		{
			return state.ReadInt16();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, short value)
		{
			state.WriteInt16(value);
		}

		public override int MeasureVarint(short value)
		{
			if (value >= 0)
			{
				return ProtoWriter.MeasureUInt32((uint)value);
			}
			return 10;
		}

		public override int MeasureSignedVarint(short value)
		{
			return ProtoWriter.MeasureUInt32(ProtoWriter.Zig(value));
		}
	}
	internal sealed class EnumSerializerInt32<T> : EnumSerializer<T, int> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override int Read(ref ProtoReader.State state)
		{
			return state.ReadInt32();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, int value)
		{
			state.WriteInt32(value);
		}

		public override int MeasureVarint(int value)
		{
			if (value >= 0)
			{
				return ProtoWriter.MeasureUInt32((uint)value);
			}
			return 10;
		}

		public override int MeasureSignedVarint(int value)
		{
			return ProtoWriter.MeasureUInt32(ProtoWriter.Zig(value));
		}
	}
	internal sealed class EnumSerializerInt64<T> : EnumSerializer<T, long> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override long Read(ref ProtoReader.State state)
		{
			return state.ReadInt64();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, long value)
		{
			state.WriteInt64(value);
		}

		public override int MeasureVarint(long value)
		{
			return ProtoWriter.MeasureUInt64((ulong)value);
		}

		public override int MeasureSignedVarint(long value)
		{
			return ProtoWriter.MeasureUInt64(ProtoWriter.Zig(value));
		}
	}
	internal sealed class EnumSerializerByte<T> : EnumSerializer<T, byte> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override byte Read(ref ProtoReader.State state)
		{
			return state.ReadByte();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, byte value)
		{
			state.WriteByte(value);
		}

		public override int MeasureVarint(byte value)
		{
			return ProtoWriter.MeasureUInt32(value);
		}
	}
	internal sealed class EnumSerializerUInt16<T> : EnumSerializer<T, ushort> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override ushort Read(ref ProtoReader.State state)
		{
			return state.ReadUInt16();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, ushort value)
		{
			state.WriteUInt16(value);
		}

		public override int MeasureVarint(ushort value)
		{
			return ProtoWriter.MeasureUInt32(value);
		}
	}
	internal sealed class EnumSerializerUInt32<T> : EnumSerializer<T, uint> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override uint Read(ref ProtoReader.State state)
		{
			return state.ReadUInt32();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, uint value)
		{
			state.WriteUInt32(value);
		}

		public override int MeasureVarint(uint value)
		{
			return ProtoWriter.MeasureUInt32(value);
		}
	}
	internal sealed class EnumSerializerUInt64<T> : EnumSerializer<T, ulong> where T : unmanaged
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected override ulong Read(ref ProtoReader.State state)
		{
			return state.ReadUInt64();
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public override void Write(ref ProtoWriter.State state, ulong value)
		{
			state.WriteUInt64(value);
		}

		public override int MeasureVarint(ulong value)
		{
			return ProtoWriter.MeasureUInt64(value);
		}
	}
	internal interface IMemoryConverter<TStorage, TElement>
	{
		TStorage NonNull(in TStorage value);

		int GetLength(in TStorage value);

		Memory<TElement> GetMemory(in TStorage value);

		Memory<TElement> Expand(ISerializationContext context, ref TStorage value, int additionalCapacity);
	}
	internal sealed class DefaultMemoryConverter<T> : IMemoryConverter<T[], T>, IMemoryConverter<ArraySegment<T>, T>, IMemoryConverter<Memory<T>, T>, IMemoryConverter<ReadOnlyMemory<T>, T>
	{
		public static DefaultMemoryConverter<T> Instance { get; } = new DefaultMemoryConverter<T>();


		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static IMemoryConverter<TStorage, T> GetFor<TStorage>(TypeModel model)
		{
			return (model?.GetSerializerCore<TStorage>(CompatibilityLevel.NotSpecified) as IMemoryConverter<TStorage, T>) ?? (Instance as IMemoryConverter<TStorage, T>) ?? NotSupported<TStorage>();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static IMemoryConverter<TStorage, T> NotSupported<TStorage>()
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("No memory-converter is available for storage " + typeof(TStorage).NormalizeName() + " with element-type " + typeof(T).NormalizeName() + ".");
			return null;
		}

		private DefaultMemoryConverter()
		{
		}

		T[] IMemoryConverter<T[], T>.NonNull(in T[] value)
		{
			return value ?? Array.Empty<T>();
		}

		int IMemoryConverter<T[], T>.GetLength(in T[] value)
		{
			if (value != null)
			{
				return value.Length;
			}
			return 0;
		}

		Memory<T> IMemoryConverter<T[], T>.GetMemory(in T[] value)
		{
			return new Memory<T>(value);
		}

		Memory<T> IMemoryConverter<T[], T>.Expand(ISerializationContext context, ref T[] value, int additionalCapacity)
		{
			int num = ((value != null) ? value.Length : 0);
			Array.Resize(ref value, num + additionalCapacity);
			return new Memory<T>(value, num, additionalCapacity);
		}

		ArraySegment<T> IMemoryConverter<ArraySegment<T>, T>.NonNull(in ArraySegment<T> value)
		{
			return value;
		}

		int IMemoryConverter<ArraySegment<T>, T>.GetLength(in ArraySegment<T> value)
		{
			ArraySegment<T> arraySegment = value;
			return arraySegment.Count;
		}

		Memory<T> IMemoryConverter<ArraySegment<T>, T>.GetMemory(in ArraySegment<T> value)
		{
			ArraySegment<T> arraySegment = value;
			T[]? array = arraySegment.Array;
			arraySegment = value;
			int offset = arraySegment.Offset;
			arraySegment = value;
			return new Memory<T>(array, offset, arraySegment.Count);
		}

		Memory<T> IMemoryConverter<ArraySegment<T>, T>.Expand(ISerializationContext context, ref ArraySegment<T> value, int additionalCapacity)
		{
			int count = value.Count;
			T[] array = new T[count + additionalCapacity];
			if (count != 0)
			{
				Array.Copy(value.Array, value.Offset, array, 0, count);
			}
			value = new ArraySegment<T>(array);
			return new Memory<T>(array, count, additionalCapacity);
		}

		Memory<T> IMemoryConverter<Memory<T>, T>.NonNull(in Memory<T> value)
		{
			return value;
		}

		int IMemoryConverter<Memory<T>, T>.GetLength(in Memory<T> value)
		{
			return value.Length;
		}

		Memory<T> IMemoryConverter<Memory<T>, T>.GetMemory(in Memory<T> value)
		{
			return value;
		}

		Memory<T> IMemoryConverter<Memory<T>, T>.Expand(ISerializationContext context, ref Memory<T> value, int additionalCapacity)
		{
			Memory<T> memory = value;
			value = new T[memory.Length + additionalCapacity];
			memory.CopyTo(value);
			return value.Slice(memory.Length);
		}

		ReadOnlyMemory<T> IMemoryConverter<ReadOnlyMemory<T>, T>.NonNull(in ReadOnlyMemory<T> value)
		{
			return value;
		}

		int IMemoryConverter<ReadOnlyMemory<T>, T>.GetLength(in ReadOnlyMemory<T> value)
		{
			return value.Length;
		}

		Memory<T> IMemoryConverter<ReadOnlyMemory<T>, T>.GetMemory(in ReadOnlyMemory<T> value)
		{
			return MemoryMarshal.AsMemory(value);
		}

		Memory<T> IMemoryConverter<ReadOnlyMemory<T>, T>.Expand(ISerializationContext context, ref ReadOnlyMemory<T> value, int additionalCapacity)
		{
			int length = value.Length;
			Memory<T> memory = new T[length + additionalCapacity];
			value.CopyTo(memory);
			value = memory;
			return memory.Slice(length);
		}
	}
	[Flags]
	internal enum SerializerFeatures
	{
		WireTypeVarint = 0x10,
		WireTypeFixed64 = 0x11,
		WireTypeString = 0x12,
		WireTypeStartGroup = 0x13,
		WireTypeFixed32 = 0x15,
		WireTypeSignedVarint = 0x18,
		WireTypeSpecified = 0x10,
		CategoryRepeated = 0,
		CategoryScalar = 0x20,
		CategoryMessage = 0x40,
		CategoryMessageWrappedAtRoot = 0x60,
		OptionPackedDisabled = 0x80,
		OptionClearCollection = 0x100,
		OptionFailOnDuplicateKey = 0x200,
		OptionSkipRecursionCheck = 0x400,
		OptionWrappedValue = 0x800,
		OptionWrappedValueGroup = 0x1000,
		OptionWrappedValueFieldPresence = 0x2000,
		OptionWrappedCollection = 0x4000,
		OptionWrappedCollectionGroup = 0x8000
	}
	internal static class SerializerFeaturesExtensions
	{
		private const SerializerFeatures CategoryMask = SerializerFeatures.CategoryMessageWrappedAtRoot;

		private const SerializerFeatures WireTypeMask = (SerializerFeatures)15;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SerializerFeatures AsFeatures(this WireType wireType)
		{
			if (wireType != WireType.None)
			{
				return (SerializerFeatures)((wireType & (WireType)15) | (WireType)16);
			}
			return SerializerFeatures.CategoryRepeated;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static SerializerFeatures GetCategory(this SerializerFeatures features)
		{
			return features & SerializerFeatures.CategoryMessageWrappedAtRoot;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void InheritFrom(this ref SerializerFeatures features, SerializerFeatures overrides)
		{
			if ((features & SerializerFeatures.CategoryMessageWrappedAtRoot) == 0)
			{
				features |= overrides & SerializerFeatures.CategoryMessageWrappedAtRoot;
			}
			if ((features & SerializerFeatures.WireTypeVarint) == 0)
			{
				features |= overrides & (SerializerFeatures)31;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void HintIfNeeded(this SerializerFeatures features, ref ProtoReader.State state)
		{
			if ((features & (SerializerFeatures)15) == (SerializerFeatures)8)
			{
				state.Hint(WireType.SignedVariant);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowInvalidCategory(this SerializerFeatures features)
		{
			SerializerFeatures category = features.GetCategory();
			string message = ((category == features) ? $"The category {category} is not expected in this context" : $"The category {category} is not expected in this context (full features: {features})");
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException(message);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsPackedDisabled(this SerializerFeatures features)
		{
			return (features & (SerializerFeatures.OptionPackedDisabled | SerializerFeatures.OptionWrappedValue)) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsScalar(this SerializerFeatures features)
		{
			return features.GetCategory() == SerializerFeatures.CategoryScalar;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsRepeated(this SerializerFeatures features)
		{
			return (features & SerializerFeatures.CategoryMessageWrappedAtRoot) == 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsGroup(this SerializerFeatures features)
		{
			return (features & (SerializerFeatures)31) == SerializerFeatures.WireTypeStartGroup;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool HasAny(this SerializerFeatures features, SerializerFeatures values)
		{
			return (features & values) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T DefaultFor<T>(this SerializerFeatures features)
		{
			if (!features.HasAny(SerializerFeatures.OptionWrappedValue))
			{
				return TypeHelper<T>.Default;
			}
			return default(T);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowWireTypeNotSpecified()
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The serializer features provided do not include a wire-type");
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static WireType GetWireType(this SerializerFeatures features)
		{
			if ((features & SerializerFeatures.WireTypeVarint) == 0)
			{
				ThrowWireTypeNotSpecified();
			}
			return (WireType)(features & (SerializerFeatures)15);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool ApplyRecursionCheck(this SerializerFeatures features)
		{
			return (features & SerializerFeatures.OptionSkipRecursionCheck) == 0;
		}
	}
	internal interface ISerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>
	{
		SerializerFeatures Features { get; }

		T Read(ref ProtoReader.State state, T value);

		void Write(ref ProtoWriter.State state, T value);
	}
	internal interface ISerializerProxy<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>
	{
		ISerializer<T> Serializer { get; }
	}
	internal interface IMeasuringSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T> : ISerializer<T>
	{
		int Measure(ISerializationContext context, WireType wireType, T value);
	}
	internal interface IRepeatedSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T> : ISerializer<T>
	{
		void WriteRepeated(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures features, T values);

		T ReadRepeated(ref ProtoReader.State state, SerializerFeatures features, T values);
	}
	[Obsolete("This API is deprecated and is never used; it will be removed soon", true)]
	internal interface IObjectSerializer<T> : ISerializer<T>
	{
		Type BaseType { get; }
	}
	internal interface ISubTypeSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T> where T : class
	{
		void WriteSubType(ref ProtoWriter.State state, T value);

		T ReadSubType(ref ProtoReader.State state, SubTypeState<T> value);
	}
	[StructLayout(LayoutKind.Auto)]
	internal struct SubTypeState<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T> where T : class
	{
		private readonly ISerializationContext _context;

		private readonly Func<ISerializationContext, object> _ctor;

		private object _value;

		private Action<T, ISerializationContext> _onBeforeDeserialize;

		public T Value
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return (_value as T) ?? Cast();
			}
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			set
			{
				_value = value;
			}
		}

		internal object RawValue => _value;

		public bool HasValue => _value != null;

		public static SubTypeState<T> Create<TValue>(ISerializationContext context, TValue value) where TValue : class, T
		{
			return new SubTypeState<T>(context, TypeHelper<T>.Factory, value, null);
		}

		private SubTypeState(ISerializationContext context, Func<ISerializationContext, object> ctor, object value, Action<T, ISerializationContext> onBeforeDeserialize)
		{
			_context = context;
			_ctor = ctor;
			_value = value;
			_onBeforeDeserialize = onBeforeDeserialize;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void CreateIfNeeded()
		{
			_ = Value;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private T Cast()
		{
			T val = ((_ctor as Func<ISerializationContext, T>) ?? TypeHelper<T>.Factory)(_context);
			if (_value != null)
			{
				val = Merge(_context, _value, val);
			}
			_onBeforeDeserialize?.Invoke(val, _context);
			_value = val;
			return val;
			static T Merge(ISerializationContext context, object value, T typed)
			{
				using MemoryStream memoryStream = new MemoryStream();
				context.Model.Serialize(memoryStream, value, context.UserState);
				memoryStream.Position = 0L;
				return context.Model.Deserialize(memoryStream, typed, context.UserState);
			}
		}

		public void ReadSubType<TSubType>(ref ProtoReader.State state, ISubTypeSerializer<TSubType> serializer = null) where TSubType : class, T
		{
			SubItemToken token = state.StartSubItem();
			_value = (serializer ?? TypeModel.GetSubTypeSerializer<TSubType>(_context.Model)).ReadSubType(ref state, new SubTypeState<TSubType>(_context, _ctor, _value, _onBeforeDeserialize));
			state.EndSubItem(token);
		}

		public void OnBeforeDeserialize(Action<T, ISerializationContext> callback)
		{
			if (callback != null)
			{
				if (_value is T arg)
				{
					callback(arg, _context);
				}
				else if (_onBeforeDeserialize != null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Only one pending OnBeforeDeserialize callback is supported");
				}
				else
				{
					_onBeforeDeserialize = callback;
				}
			}
		}
	}
	internal interface IFactory<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>
	{
		T Create(ISerializationContext context);
	}
	internal static class MapSerializer
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static MapSerializer<TCollection, TKey, TValue> CreateConcurrentDictionary<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue>() where TCollection : ConcurrentDictionary<TKey, TValue>
		{
			return SerializerCache<ConcurrentDictionarySerializer<TCollection, TKey, TValue>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static MapSerializer<Dictionary<TKey, TValue>, TKey, TValue> CreateDictionary<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue>()
		{
			return SerializerCache<DictionarySerializer<TKey, TValue>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static MapSerializer<TCollection, TKey, TValue> CreateDictionary<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue>() where TCollection : IDictionary<TKey, TValue>
		{
			return SerializerCache<DictionarySerializer<TCollection, TKey, TValue>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static MapSerializer<IReadOnlyDictionary<TKey, TValue>, TKey, TValue> CreateIReadOnlyDictionary<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue>()
		{
			return SerializerCache<DictionaryOfIReadOnlyDictionarySerializer<TKey, TValue>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static MapSerializer<ImmutableDictionary<TKey, TValue>, TKey, TValue> CreateImmutableDictionary<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue>()
		{
			return SerializerCache<ImmutableDictionarySerializer<TKey, TValue>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static MapSerializer<ImmutableSortedDictionary<TKey, TValue>, TKey, TValue> CreateImmutableSortedDictionary<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue>()
		{
			return SerializerCache<ImmutableSortedDictionarySerializer<TKey, TValue>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static MapSerializer<IImmutableDictionary<TKey, TValue>, TKey, TValue> CreateIImmutableDictionary<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue>()
		{
			return SerializerCache<ImmutableIDictionarySerializer<TKey, TValue>>.InstanceField;
		}
	}
	internal sealed class ConcurrentDictionarySerializer<TCollection, TKey, TValue> : MapSerializer<TCollection, TKey, TValue> where TCollection : ConcurrentDictionary<TKey, TValue>
	{
		protected override TCollection Clear(TCollection values, ISerializationContext context)
		{
			values.Clear();
			return values;
		}

		protected override TCollection Initialize(TCollection values, ISerializationContext context)
		{
			return values ?? TypeModel.ActivatorCreate<TCollection>();
		}

		protected override TCollection AddRange(TCollection values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				KeyValuePair<TKey, TValue> keyValuePair = span[i];
				if (!values.TryAdd(keyValuePair.Key, keyValuePair.Value))
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentException("duplicate key");
				}
			}
			return values;
		}

		protected override TCollection SetValues(TCollection values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				KeyValuePair<TKey, TValue> keyValuePair = span[i];
				values[keyValuePair.Key] = keyValuePair.Value;
			}
			return values;
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, TCollection values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			IEnumerator<KeyValuePair<TKey, TValue>> enumerator = values.GetEnumerator();
			try
			{
				MapSerializer<TCollection, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
			}
			finally
			{
				enumerator?.Dispose();
			}
		}
	}
	internal abstract class MapSerializer<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue> : IRepeatedSerializer<TCollection>, ISerializer<TCollection>, IFactory<TCollection>
	{
		SerializerFeatures ISerializer<TCollection>.Features => SerializerFeatures.CategoryRepeated;

		TCollection IFactory<TCollection>.Create(ISerializationContext context)
		{
			return Initialize(default(TCollection), context);
		}

		TCollection ISerializer<TCollection>.Read(ref ProtoReader.State state, TCollection value)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Should have used ReadRepeated");
			return default(TCollection);
		}

		void ISerializer<TCollection>.Write(ref ProtoWriter.State state, TCollection value)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Should have used WriteRepeated");
		}

		void IRepeatedSerializer<TCollection>.WriteRepeated(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures features, TCollection values)
		{
			WriteMap(ref state, fieldNumber, features, values, SerializerFeatures.CategoryRepeated, SerializerFeatures.CategoryRepeated);
		}

		TCollection IRepeatedSerializer<TCollection>.ReadRepeated(ref ProtoReader.State state, SerializerFeatures features, TCollection values)
		{
			return ReadMap(ref state, features, values, SerializerFeatures.CategoryRepeated, SerializerFeatures.CategoryRepeated);
		}

		private static KeyValuePairSerializer<TKey, TValue> GetSerializer(TypeModel model, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer, ISerializer<TValue> valueSerializer)
		{
			if (keySerializer == null)
			{
				keySerializer = TypeModel.GetSerializer<TKey>(model);
			}
			if (valueSerializer == null)
			{
				valueSerializer = TypeModel.GetSerializer<TValue>(model);
			}
			keyFeatures.InheritFrom(keySerializer.Features);
			valueFeatures.InheritFrom(valueSerializer.Features);
			return new KeyValuePairSerializer<TKey, TValue>(keySerializer, keyFeatures, valueSerializer, valueFeatures);
		}

		public void WriteMap(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures features, TCollection values, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer = null, ISerializer<TValue> valueSerializer = null)
		{
			if (features.HasAny(SerializerFeatures.OptionWrappedCollection))
			{
				WriteNullWrapped(ref state, features, fieldNumber, values, keyFeatures, valueFeatures, keySerializer, valueSerializer);
				return;
			}
			KeyValuePairSerializer<TKey, TValue> pairSerializer = GetSerializer(state.Model, keyFeatures, valueFeatures, keySerializer, valueSerializer);
			features.InheritFrom(pairSerializer.Features);
			WireType wireType = features.GetWireType();
			Write(ref state, fieldNumber, wireType, values, in pairSerializer);
		}

		private void WriteNullWrapped(ref ProtoWriter.State state, SerializerFeatures features, int fieldNumber, TCollection values, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer, ISerializer<TValue> valueSerializer)
		{
			state.WriteFieldHeader(fieldNumber, ProtoWriter.State.AssertWrappedAndGetWireType(ref features, out var _));
			state.GetWriter().WriteWrappedMap(ref state, features, values, this, keyFeatures, valueFeatures, keySerializer, valueSerializer);
		}

		internal abstract void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, TCollection values, in KeyValuePairSerializer<TKey, TValue> pairSerializer);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Write<TEnumerator>(ref ProtoWriter.State state, int fieldNumber, WireType wireType, ref TEnumerator enumerator, in KeyValuePairSerializer<TKey, TValue> pairSerializer) where TEnumerator : IEnumerator<KeyValuePair<TKey, TValue>>
		{
			if (enumerator.MoveNext())
			{
				ISerializer<KeyValuePair<TKey, TValue>> serializer = pairSerializer;
				do
				{
					state.WriteFieldHeader(fieldNumber, wireType);
					state.GetWriter().WriteMessage(ref state, enumerator.Current, serializer, PrefixStyle.Base128, recursionCheck: false);
				}
				while (enumerator.MoveNext());
			}
		}

		protected virtual TCollection Initialize(TCollection values, ISerializationContext context)
		{
			return values;
		}

		protected abstract TCollection Clear(TCollection values, ISerializationContext context);

		protected abstract TCollection AddRange(TCollection values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context);

		protected abstract TCollection SetValues(TCollection values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context);

		public TCollection ReadMap(ref ProtoReader.State state, SerializerFeatures features, TCollection values, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer = null, ISerializer<TValue> valueSerializer = null)
		{
			if (features.HasAny(SerializerFeatures.OptionWrappedCollection))
			{
				return ReadNullWrapped(ref state, features, values, keyFeatures, valueFeatures, keySerializer, valueSerializer);
			}
			ISerializationContext context = state.Context;
			KeyValuePairSerializer<TKey, TValue> serializer = GetSerializer(state.Model, keyFeatures, valueFeatures, keySerializer, valueSerializer);
			features.InheritFrom(serializer.Features);
			values = Initialize(values, context);
			using ReadBuffer<KeyValuePair<TKey, TValue>> readBuffer = state.FillBuffer(features, in serializer, new KeyValuePair<TKey, TValue>(TypeHelper<TKey>.Default, features.DefaultFor<TValue>()));
			if ((features & SerializerFeatures.OptionClearCollection) != 0)
			{
				values = Clear(values, context);
			}
			if (!readBuffer.IsEmpty)
			{
				ArraySegment<KeyValuePair<TKey, TValue>> newValues = readBuffer.Segment;
				values = (((features & SerializerFeatures.OptionFailOnDuplicateKey) == 0) ? SetValues(values, ref newValues, context) : AddRange(values, ref newValues, context));
			}
			return values;
		}

		private TCollection ReadNullWrapped(ref ProtoReader.State state, SerializerFeatures features, TCollection values, SerializerFeatures keyFeatures, SerializerFeatures valueFeatures, ISerializer<TKey> keySerializer, ISerializer<TValue> valueSerializer)
		{
			features &= ~(SerializerFeatures.OptionWrappedCollection | SerializerFeatures.OptionWrappedCollectionGroup);
			SubItemToken token = state.StartSubItem();
			bool flag = true;
			int num;
			while ((num = state.ReadFieldHeader()) > 0)
			{
				if (num == 1)
				{
					values = ReadMap(ref state, features, values, keyFeatures, valueFeatures, keySerializer, valueSerializer);
					flag = false;
				}
				else
				{
					state.SkipField();
				}
			}
			state.EndSubItem(token);
			if (flag)
			{
				values = Initialize(values, state.Context);
			}
			return values;
		}
	}
	internal sealed class DictionarySerializer<TKey, TValue> : MapSerializer<Dictionary<TKey, TValue>, TKey, TValue>
	{
		protected override Dictionary<TKey, TValue> Initialize(Dictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values ?? new Dictionary<TKey, TValue>();
		}

		protected override Dictionary<TKey, TValue> Clear(Dictionary<TKey, TValue> values, ISerializationContext context)
		{
			values.Clear();
			return values;
		}

		protected override Dictionary<TKey, TValue> AddRange(Dictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				KeyValuePair<TKey, TValue> keyValuePair = span[i];
				values.Add(keyValuePair.Key, keyValuePair.Value);
			}
			return values;
		}

		protected override Dictionary<TKey, TValue> SetValues(Dictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				KeyValuePair<TKey, TValue> keyValuePair = span[i];
				values[keyValuePair.Key] = keyValuePair.Value;
			}
			return values;
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, Dictionary<TKey, TValue> values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			Dictionary<TKey, TValue>.Enumerator enumerator = values.GetEnumerator();
			MapSerializer<Dictionary<TKey, TValue>, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
		}
	}
	internal class DictionarySerializer<TCollection, TKey, TValue> : MapSerializer<TCollection, TKey, TValue> where TCollection : IDictionary<TKey, TValue>
	{
		protected override TCollection Initialize(TCollection values, ISerializationContext context)
		{
			if (values != null)
			{
				return values;
			}
			if (!typeof(TCollection).IsInterface)
			{
				return TypeModel.ActivatorCreate<TCollection>();
			}
			return (TCollection)(object)new Dictionary<TKey, TValue>();
		}

		protected override TCollection Clear(TCollection values, ISerializationContext context)
		{
			values.Clear();
			return values;
		}

		protected override TCollection AddRange(TCollection values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				KeyValuePair<TKey, TValue> keyValuePair = span[i];
				ref TCollection reference = ref values;
				TCollection val = default(TCollection);
				if (val == null)
				{
					val = reference;
					reference = ref val;
				}
				reference.Add(keyValuePair.Key, keyValuePair.Value);
			}
			return values;
		}

		protected override TCollection SetValues(TCollection values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				KeyValuePair<TKey, TValue> keyValuePair = span[i];
				ref TCollection reference = ref values;
				TCollection val = default(TCollection);
				if (val == null)
				{
					val = reference;
					reference = ref val;
				}
				reference[keyValuePair.Key] = keyValuePair.Value;
			}
			return values;
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, TCollection values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			IEnumerator<KeyValuePair<TKey, TValue>> enumerator = values.GetEnumerator();
			try
			{
				MapSerializer<TCollection, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
			}
			finally
			{
				enumerator?.Dispose();
			}
		}
	}
	internal sealed class DictionaryOfIReadOnlyDictionarySerializer<TKey, TValue> : MapSerializer<IReadOnlyDictionary<TKey, TValue>, TKey, TValue>
	{
		protected override IReadOnlyDictionary<TKey, TValue> Initialize(IReadOnlyDictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values ?? new Dictionary<TKey, TValue>();
		}

		protected override IReadOnlyDictionary<TKey, TValue> Clear(IReadOnlyDictionary<TKey, TValue> values, ISerializationContext context)
		{
			if (values is IDictionary<TKey, TValue> dictionary && !dictionary.IsReadOnly)
			{
				dictionary.Clear();
				return values;
			}
			return new Dictionary<TKey, TValue>();
		}

		protected override IReadOnlyDictionary<TKey, TValue> AddRange(IReadOnlyDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (values is IDictionary<TKey, TValue> dictionary && !dictionary.IsReadOnly)
			{
				Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
				for (int i = 0; i < span.Length; i++)
				{
					KeyValuePair<TKey, TValue> keyValuePair = span[i];
					dictionary.Add(keyValuePair.Key, keyValuePair.Value);
				}
				return values;
			}
			Dictionary<TKey, TValue> dictionary2 = new Dictionary<TKey, TValue>(values.Count + newValues.Count);
			foreach (KeyValuePair<TKey, TValue> value in values)
			{
				dictionary2.Add(value.Key, value.Value);
			}
			Span<KeyValuePair<TKey, TValue>> span2 = MemoryExtensions.AsSpan(newValues);
			for (int j = 0; j < span2.Length; j++)
			{
				KeyValuePair<TKey, TValue> keyValuePair2 = span2[j];
				dictionary2.Add(keyValuePair2.Key, keyValuePair2.Value);
			}
			return dictionary2;
		}

		protected override IReadOnlyDictionary<TKey, TValue> SetValues(IReadOnlyDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (values is IDictionary<TKey, TValue> dictionary && !dictionary.IsReadOnly)
			{
				Span<KeyValuePair<TKey, TValue>> span = MemoryExtensions.AsSpan(newValues);
				for (int i = 0; i < span.Length; i++)
				{
					KeyValuePair<TKey, TValue> keyValuePair = span[i];
					dictionary[keyValuePair.Key] = keyValuePair.Value;
				}
				return values;
			}
			Dictionary<TKey, TValue> dictionary2 = new Dictionary<TKey, TValue>(values.Count);
			foreach (KeyValuePair<TKey, TValue> value in values)
			{
				dictionary2.Add(value.Key, value.Value);
			}
			Span<KeyValuePair<TKey, TValue>> span2 = MemoryExtensions.AsSpan(newValues);
			for (int j = 0; j < span2.Length; j++)
			{
				KeyValuePair<TKey, TValue> keyValuePair2 = span2[j];
				dictionary2[keyValuePair2.Key] = keyValuePair2.Value;
			}
			return values;
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, IReadOnlyDictionary<TKey, TValue> values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			IEnumerator<KeyValuePair<TKey, TValue>> enumerator = values.GetEnumerator();
			MapSerializer<IReadOnlyDictionary<TKey, TValue>, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
		}
	}
	internal abstract class ExternalMapSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TKey, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TValue> : MapSerializer<TCollection, TKey, TValue> where TCollection : IEnumerable<KeyValuePair<TKey, TValue>>
	{
		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, TCollection values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			IEnumerator<KeyValuePair<TKey, TValue>> enumerator = values.GetEnumerator();
			MapSerializer<TCollection, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
		}
	}
	internal sealed class ImmutableDictionarySerializer<TKey, TValue> : MapSerializer<ImmutableDictionary<TKey, TValue>, TKey, TValue>
	{
		protected override ImmutableDictionary<TKey, TValue> Clear(ImmutableDictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override ImmutableDictionary<TKey, TValue> Initialize(ImmutableDictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values ?? ImmutableDictionary<TKey, TValue>.Empty;
		}

		protected override ImmutableDictionary<TKey, TValue> AddRange(ImmutableDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				KeyValuePair<TKey, TValue> keyValuePair = RepeatedSerializer.Singleton(ref newValues);
				return values.Add(keyValuePair.Key, keyValuePair.Value);
			}
			return values.AddRange(newValues);
		}

		protected override ImmutableDictionary<TKey, TValue> SetValues(ImmutableDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				KeyValuePair<TKey, TValue> keyValuePair = RepeatedSerializer.Singleton(ref newValues);
				return values.SetItem(keyValuePair.Key, keyValuePair.Value);
			}
			return values.SetItems(newValues);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, ImmutableDictionary<TKey, TValue> values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			ImmutableDictionary<TKey, TValue>.Enumerator enumerator = values.GetEnumerator();
			MapSerializer<ImmutableDictionary<TKey, TValue>, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
		}
	}
	internal sealed class ImmutableSortedDictionarySerializer<TKey, TValue> : MapSerializer<ImmutableSortedDictionary<TKey, TValue>, TKey, TValue>
	{
		protected override ImmutableSortedDictionary<TKey, TValue> Clear(ImmutableSortedDictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override ImmutableSortedDictionary<TKey, TValue> Initialize(ImmutableSortedDictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values ?? ImmutableSortedDictionary<TKey, TValue>.Empty;
		}

		protected override ImmutableSortedDictionary<TKey, TValue> AddRange(ImmutableSortedDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				KeyValuePair<TKey, TValue> keyValuePair = RepeatedSerializer.Singleton(ref newValues);
				return values.Add(keyValuePair.Key, keyValuePair.Value);
			}
			return values.AddRange(newValues);
		}

		protected override ImmutableSortedDictionary<TKey, TValue> SetValues(ImmutableSortedDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				KeyValuePair<TKey, TValue> keyValuePair = RepeatedSerializer.Singleton(ref newValues);
				return values.SetItem(keyValuePair.Key, keyValuePair.Value);
			}
			return values.SetItems(newValues);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, ImmutableSortedDictionary<TKey, TValue> values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			ImmutableSortedDictionary<TKey, TValue>.Enumerator enumerator = values.GetEnumerator();
			MapSerializer<ImmutableSortedDictionary<TKey, TValue>, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
		}
	}
	internal sealed class ImmutableIDictionarySerializer<TKey, TValue> : MapSerializer<IImmutableDictionary<TKey, TValue>, TKey, TValue>
	{
		protected override IImmutableDictionary<TKey, TValue> Clear(IImmutableDictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override IImmutableDictionary<TKey, TValue> Initialize(IImmutableDictionary<TKey, TValue> values, ISerializationContext context)
		{
			return values ?? ImmutableDictionary<TKey, TValue>.Empty;
		}

		protected override IImmutableDictionary<TKey, TValue> AddRange(IImmutableDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				KeyValuePair<TKey, TValue> keyValuePair = RepeatedSerializer.Singleton(ref newValues);
				return values.Add(keyValuePair.Key, keyValuePair.Value);
			}
			return values.AddRange(newValues);
		}

		protected override IImmutableDictionary<TKey, TValue> SetValues(IImmutableDictionary<TKey, TValue> values, ref ArraySegment<KeyValuePair<TKey, TValue>> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				KeyValuePair<TKey, TValue> keyValuePair = RepeatedSerializer.Singleton(ref newValues);
				return values.SetItem(keyValuePair.Key, keyValuePair.Value);
			}
			return values.SetItems(newValues);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, WireType wireType, IImmutableDictionary<TKey, TValue> values, in KeyValuePairSerializer<TKey, TValue> pairSerializer)
		{
			IEnumerator<KeyValuePair<TKey, TValue>> enumerator = values.GetEnumerator();
			try
			{
				MapSerializer<IImmutableDictionary<TKey, TValue>, TKey, TValue>.Write(ref state, fieldNumber, wireType, ref enumerator, in pairSerializer);
			}
			finally
			{
				enumerator?.Dispose();
			}
		}
	}
	internal static class RepeatedSerializer
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateConcurrentBag<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : ConcurrentBag<T>
		{
			return SerializerCache<ConcurrentBagSerializer<TCollection, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateConcurrentStack<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : ConcurrentStack<T>
		{
			return SerializerCache<ConcurrentStackSerializer<TCollection, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateConcurrentQueue<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : ConcurrentQueue<T>
		{
			return SerializerCache<ConcurrentQueueSerializer<TCollection, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateIProducerConsumerCollection<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : class, IProducerConsumerCollection<T>
		{
			return SerializerCache<ProducerConsumerSerializer<TCollection, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Obsolete("Since this isn't supported, you probably shouldn't be doing it...", false)]
		public static RepeatedSerializer<TCollection, T> CreateNestedDataNotSupported<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNestedDataNotSupported(typeof(TCollection));
			return null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		[Obsolete("Since this isn't supported, you probably shouldn't be doing it...", false)]
		public static RepeatedSerializer<TCollection, T> CreateNotSupported<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException($"Repeated data of type {typeof(TCollection)} is not supported");
			return null;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<List<T>, T> CreateList<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ListSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TList, T> CreateList<TList, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TList : List<T>
		{
			return SerializerCache<ListSerializer<TList, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateEnumerable<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : class, IEnumerable<T>
		{
			return SerializerCache<EnumerableSerializer<TCollection, TCollection, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateEnumerable<TCollection, TCreate, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : class, IEnumerable<T> where TCreate : TCollection
		{
			return SerializerCache<EnumerableSerializer<TCollection, TCreate, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<T[], T> CreateVector<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<VectorSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateQueue<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : Queue<T>
		{
			return SerializerCache<QueueSerializer<TCollection, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<TCollection, T> CreateStack<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TCollection : Stack<T>
		{
			return SerializerCache<StackSerializer<TCollection, T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void ReverseInPlace<T>(this ref ArraySegment<T> values)
		{
			Array.Reverse((Array)values.Array, values.Offset, values.Count);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static ref T Singleton<T>(this ref ArraySegment<T> values)
		{
			return ref values.Array[values.Offset];
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<ImmutableArray<T>, T> CreateImmutableArray<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableArraySerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<ImmutableList<T>, T> CreateImmutableList<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableListSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<IImmutableList<T>, T> CreateImmutableIList<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableIListSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<ImmutableQueue<T>, T> CreateImmutableQueue<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableQueueSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<IImmutableQueue<T>, T> CreateImmutableIQueue<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableIQueueSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<ImmutableStack<T>, T> CreateImmutableStack<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableStackSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<IImmutableStack<T>, T> CreateImmutableIStack<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableIStackSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<ImmutableHashSet<T>, T> CreateImmutableHashSet<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableHashSetSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<ImmutableSortedSet<T>, T> CreateImmutableSortedSet<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableSortedSetSerializer<T>>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static RepeatedSerializer<IImmutableSet<T>, T> CreateImmutableISet<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<ImmutableISetSerializer<T>>.InstanceField;
		}
	}
	internal class ProducerConsumerSerializer<TCollection, T> : RepeatedSerializer<TCollection, T> where TCollection : class, IProducerConsumerCollection<T>
	{
		protected override TCollection Clear(TCollection values, ISerializationContext context)
		{
			if (values.Count != 0)
			{
				if (values is ICollection<T> collection)
				{
					collection.Clear();
				}
				else
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Unable to clear the collection: " + values.GetType().NormalizeName());
				}
			}
			return values;
		}

		protected override TCollection AddRange(TCollection values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T item = span[i];
				if (!values.TryAdd(item))
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Unable to add to the collection: " + values.GetType().NormalizeName());
				}
			}
			return values;
		}

		protected override TCollection Initialize(TCollection values, ISerializationContext context)
		{
			return values ?? TypeModel.ActivatorCreate<TCollection>();
		}

		protected override int TryGetCount(TCollection values)
		{
			return TryGetCountDefault(values);
		}

		internal override long Measure(TCollection values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				return RepeatedSerializer<TCollection, T>.Measure(ref values2, serializer, context, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, TCollection values, ISerializer<T> serializer, SerializerFeatures features)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<TCollection, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void WritePacked(ref ProtoWriter.State state, TCollection values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<TCollection, T>.WritePacked(ref state, ref values2, serializer, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}
	}
	internal sealed class ConcurrentBagSerializer<TCollection, T> : ProducerConsumerSerializer<TCollection, T> where TCollection : ConcurrentBag<T>
	{
		protected override TCollection AddRange(TCollection values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T item = span[i];
				values.Add(item);
			}
			return values;
		}
	}
	internal sealed class ConcurrentQueueSerializer<TCollection, T> : ProducerConsumerSerializer<TCollection, T> where TCollection : ConcurrentQueue<T>
	{
		protected override TCollection AddRange(TCollection values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T item = span[i];
				values.Enqueue(item);
			}
			return values;
		}
	}
	internal sealed class ConcurrentStackSerializer<TCollection, T> : ProducerConsumerSerializer<TCollection, T> where TCollection : ConcurrentStack<T>
	{
		protected override TCollection Clear(TCollection values, ISerializationContext context)
		{
			values.Clear();
			return values;
		}

		protected override TCollection AddRange(TCollection values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			RepeatedSerializer.ReverseInPlace(ref newValues);
			values.PushRange(newValues.Array, newValues.Offset, newValues.Count);
			return values;
		}
	}
	internal abstract class RepeatedSerializer<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] TItem> : IRepeatedSerializer<TCollection>, ISerializer<TCollection>, IFactory<TCollection>
	{
		SerializerFeatures ISerializer<TCollection>.Features => SerializerFeatures.CategoryRepeated;

		TCollection IFactory<TCollection>.Create(ISerializationContext context)
		{
			return Initialize(default(TCollection), context);
		}

		void IRepeatedSerializer<TCollection>.WriteRepeated(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures features, TCollection values)
		{
			WriteRepeated(ref state, fieldNumber, features, values);
		}

		TCollection IRepeatedSerializer<TCollection>.ReadRepeated(ref ProtoReader.State state, SerializerFeatures features, TCollection values)
		{
			return ReadRepeated(ref state, features, values);
		}

		TCollection ISerializer<TCollection>.Read(ref ProtoReader.State state, TCollection value)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Should have used ReadRepeated");
			return default(TCollection);
		}

		void ISerializer<TCollection>.Write(ref ProtoWriter.State state, TCollection value)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Should have used WriteRepeated");
		}

		private void WriteNullWrapped(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures features, TCollection values, ISerializer<TItem> serializer)
		{
			if (!TypeHelper<TCollection>.CanBeNull || !TypeHelper<TCollection>.ValueChecker.IsNull(values))
			{
				state.WriteFieldHeader(fieldNumber, ProtoWriter.State.AssertWrappedAndGetWireType(ref features, out var _));
				state.GetWriter().WriteWrappedCollection(ref state, features, values, this, serializer);
			}
		}

		public void WriteRepeated(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures features, TCollection values, ISerializer<TItem> serializer = null)
		{
			if (features.HasAny(SerializerFeatures.OptionWrappedCollection))
			{
				WriteNullWrapped(ref state, fieldNumber, features, values, serializer);
				return;
			}
			if (serializer == null)
			{
				serializer = TypeModel.GetSerializer<TItem>(state.Model);
			}
			SerializerFeatures features2 = serializer.Features;
			if (features2.IsRepeated())
			{
				TypeModel.ThrowNestedListsNotSupported(typeof(TItem));
			}
			features.InheritFrom(features2);
			int num = TryGetCount(values);
			SerializerFeatures category = features2.GetCategory();
			WireType wireType = features.GetWireType();
			if (TypeHelper<TItem>.CanBePacked && !features.IsPackedDisabled() && (num == 0 || num > 1) && serializer is IMeasuringSerializer<TItem> serializer2)
			{
				if (category != SerializerFeatures.CategoryScalar)
				{
					features2.ThrowInvalidCategory();
				}
				if (num == 0)
				{
					WriteZeroLengthPackedHeader(ref state, fieldNumber);
				}
				else
				{
					WritePacked(ref state, fieldNumber, wireType, values, num, serializer2);
				}
			}
			else if (num != 0)
			{
				Write(ref state, fieldNumber, category, wireType, values, serializer, features);
			}
		}

		private static void WriteZeroLengthPackedHeader(ref ProtoWriter.State state, int fieldNumber)
		{
			if (state.Model.OmitsOption(TypeModel.TypeModelOptions.SkipZeroLengthPackedArrays))
			{
				state.WriteFieldHeader(fieldNumber, WireType.String);
				ProtoWriter writer = state.GetWriter();
				writer.AdvanceAndReset(writer.ImplWriteVarint64(ref state, 0uL));
			}
		}

		internal abstract void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, TCollection values, ISerializer<TItem> serializer, SerializerFeatures features);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void Write<TEnumerator>(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ref TEnumerator values, ISerializer<TItem> serializer, SerializerFeatures features) where TEnumerator : IEnumerator<TItem>
		{
			ProtoWriter writer = state.GetWriter();
			bool flag = features.HasAny(SerializerFeatures.OptionWrappedValue);
			if (flag)
			{
				features |= SerializerFeatures.OptionWrappedValueFieldPresence;
			}
			while (values.MoveNext())
			{
				TItem current = values.Current;
				if (flag)
				{
					state.WriteWrapped(fieldNumber, features, current, serializer);
					continue;
				}
				if (TypeHelper<TItem>.CanBeNull && TypeHelper<TItem>.ValueChecker.IsNull(current))
				{
					ProtoBuf.Internal.ThrowHelper.ThrowNullRepeatedContents<TItem>();
				}
				state.WriteFieldHeader(fieldNumber, wireType);
				switch (category)
				{
				case SerializerFeatures.CategoryMessage:
				case SerializerFeatures.CategoryMessageWrappedAtRoot:
					writer.WriteMessage(ref state, current, serializer, PrefixStyle.Base128, recursionCheck: true);
					break;
				case SerializerFeatures.CategoryScalar:
					serializer.Write(ref state, current);
					break;
				default:
					category.ThrowInvalidCategory();
					break;
				}
			}
		}

		internal abstract long Measure(TCollection values, IMeasuringSerializer<TItem> serializer, ISerializationContext context, WireType wireType);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static long Measure<TEnumerator>(ref TEnumerator values, IMeasuringSerializer<TItem> serializer, ISerializationContext context, WireType wireType) where TEnumerator : IEnumerator<TItem>
		{
			long num = 0L;
			while (values.MoveNext())
			{
				num += serializer.Measure(context, wireType, values.Current);
			}
			return num;
		}

		internal abstract void WritePacked(ref ProtoWriter.State state, TCollection values, IMeasuringSerializer<TItem> serializer, WireType wireType);

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static void WritePacked<TEnumerator>(ref ProtoWriter.State state, ref TEnumerator values, IMeasuringSerializer<TItem> serializer, WireType wireType) where TEnumerator : IEnumerator<TItem>
		{
			while (values.MoveNext())
			{
				TItem current = values.Current;
				state.WireType = wireType;
				serializer.Write(ref state, current);
			}
		}

		private void WritePacked(ref ProtoWriter.State state, int fieldNumber, WireType wireType, TCollection values, int count, IMeasuringSerializer<TItem> serializer)
		{
			long num;
			switch (wireType)
			{
			case WireType.Fixed32:
				num = count * 4;
				break;
			case WireType.Fixed64:
				num = count * 8;
				break;
			case WireType.Variant:
			case WireType.SignedVariant:
				num = Measure(values, serializer, state.Context, wireType);
				break;
			default:
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidPackedOperationException(wireType, typeof(TItem));
				num = 0L;
				break;
			}
			state.WriteFieldHeader(fieldNumber, WireType.String);
			ProtoWriter writer = state.GetWriter();
			writer.AdvanceAndReset(writer.ImplWriteVarint64(ref state, (ulong)num));
			long position = state.GetPosition();
			WritePacked(ref state, values, serializer, wireType);
			long num2 = state.GetPosition() - position;
			if (num2 != num)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException($"packed encoding length miscalculation for {typeof(TItem).NormalizeName()}, {wireType}; expected {num}, got {num2}");
			}
		}

		protected abstract int TryGetCount(TCollection values);

		protected int TryGetCountDefault(TCollection values)
		{
			try
			{
				return ((object)values is IReadOnlyCollection<TItem> readOnlyCollection) ? readOnlyCollection.Count : (((object)values is ICollection<TItem> collection) ? collection.Count : (((object)values is ICollection collection2) ? collection2.Count : ((values != null) ? (-1) : 0)));
			}
			catch
			{
				return -1;
			}
		}

		private TCollection ReadNullWrapped(ref ProtoReader.State state, SerializerFeatures features, TCollection values, ISerializer<TItem> serializer)
		{
			features &= ~(SerializerFeatures.OptionWrappedCollection | SerializerFeatures.OptionWrappedCollectionGroup);
			SubItemToken token = state.StartSubItem();
			bool flag = true;
			int num;
			while ((num = state.ReadFieldHeader()) > 0)
			{
				if (num == 1)
				{
					values = ReadRepeated(ref state, features, values, serializer);
					flag = false;
				}
				else
				{
					state.SkipField();
				}
			}
			state.EndSubItem(token);
			if (flag)
			{
				values = Initialize(values, state.Context);
			}
			return values;
		}

		public TCollection ReadRepeated(ref ProtoReader.State state, SerializerFeatures features, TCollection values, ISerializer<TItem> serializer = null)
		{
			if (features.HasAny(SerializerFeatures.OptionWrappedCollection))
			{
				return ReadNullWrapped(ref state, features, values, serializer);
			}
			if (serializer == null)
			{
				serializer = TypeModel.GetSerializer<TItem>(state.Model);
			}
			SerializerFeatures features2 = serializer.Features;
			if (features2.IsRepeated())
			{
				TypeModel.ThrowNestedListsNotSupported(typeof(TItem));
			}
			features.InheritFrom(features2);
			if (features.HasAny(SerializerFeatures.OptionWrappedValue))
			{
				features |= SerializerFeatures.OptionWrappedValueFieldPresence;
			}
			ISerializationContext context = state.Context;
			values = Initialize(values, context);
			using ReadBuffer<TItem> readBuffer = state.FillBuffer(features, in serializer, features.DefaultFor<TItem>());
			if ((features & SerializerFeatures.OptionClearCollection) != 0)
			{
				values = Clear(values, context);
			}
			if (readBuffer.IsEmpty)
			{
				return values;
			}
			ArraySegment<TItem> newValues = readBuffer.Segment;
			return AddRange(values, ref newValues, context);
		}

		protected virtual TCollection Initialize(TCollection values, ISerializationContext context)
		{
			return values;
		}

		protected abstract TCollection Clear(TCollection values, ISerializationContext context);

		protected abstract TCollection AddRange(TCollection values, ref ArraySegment<TItem> newValues, ISerializationContext context);
	}
	internal sealed class StackSerializer<TCollection, T> : RepeatedSerializer<TCollection, T> where TCollection : Stack<T>
	{
		protected override TCollection Initialize(TCollection values, ISerializationContext context)
		{
			return values ?? TypeModel.ActivatorCreate<TCollection>();
		}

		protected override TCollection Clear(TCollection values, ISerializationContext context)
		{
			values.Clear();
			return values;
		}

		protected override int TryGetCount(TCollection values)
		{
			return values?.Count ?? 0;
		}

		protected override TCollection AddRange(TCollection values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			RepeatedSerializer.ReverseInPlace(ref newValues);
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T item = span[i];
				values.Push(item);
			}
			return values;
		}

		internal override long Measure(TCollection values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			Stack<T>.Enumerator values2 = values.GetEnumerator();
			return RepeatedSerializer<TCollection, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void WritePacked(ref ProtoWriter.State state, TCollection values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			Stack<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<TCollection, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, TCollection values, ISerializer<T> serializer, SerializerFeatures features)
		{
			Stack<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<TCollection, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}
	}
	internal sealed class ListSerializer<T> : ListSerializer<List<T>, T>
	{
		protected override List<T> Initialize(List<T> values, ISerializationContext context)
		{
			return values ?? new List<T>();
		}
	}
	internal class ListSerializer<TList, T> : RepeatedSerializer<TList, T> where TList : List<T>
	{
		protected override TList Initialize(TList values, ISerializationContext context)
		{
			return values ?? TypeModel.ActivatorCreate<TList>();
		}

		protected override TList Clear(TList values, ISerializationContext context)
		{
			values.Clear();
			return values;
		}

		protected override TList AddRange(TList values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			values.AddRange(newValues);
			return values;
		}

		protected override int TryGetCount(TList values)
		{
			return values?.Count ?? 0;
		}

		internal override long Measure(TList values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			List<T>.Enumerator values2 = values.GetEnumerator();
			return RepeatedSerializer<TList, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void WritePacked(ref ProtoWriter.State state, TList values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			List<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<TList, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, TList values, ISerializer<T> serializer, SerializerFeatures features)
		{
			List<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<TList, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}
	}
	internal class EnumerableSerializer<TCollection, TCreate, T> : RepeatedSerializer<TCollection, T> where TCollection : class, IEnumerable<T> where TCreate : TCollection
	{
		protected override TCollection Initialize(TCollection values, ISerializationContext context)
		{
			object obj = values;
			if (obj == null)
			{
				if (!typeof(TCreate).IsInterface)
				{
					return (TCollection)(object)TypeModel.ActivatorCreate<TCreate>();
				}
				obj = (TCollection)(object)new List<T>();
			}
			return (TCollection)obj;
		}

		protected override int TryGetCount(TCollection values)
		{
			return TryGetCountDefault(values);
		}

		internal override long Measure(TCollection values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				return RepeatedSerializer<TCollection, T>.Measure(ref values2, serializer, context, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void WritePacked(ref ProtoWriter.State state, TCollection values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<TCollection, T>.WritePacked(ref state, ref values2, serializer, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, TCollection values, ISerializer<T> serializer, SerializerFeatures features)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<TCollection, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		private static void ThrowInvalidCollectionType(object collection)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("For repeated data declared as " + typeof(TCollection).NormalizeName() + ", the *underlying* collection (" + collection?.GetType().NormalizeName() + ") must implement ICollection<T> and must not declare itself read-only; alternative (more exotic) collections can be used, but must be declared using their well-known form (for example, a member could be declared as ImmutableHashSet<T>)");
		}

		protected override TCollection Clear(TCollection values, ISerializationContext context)
		{
			if (values is ICollection<T> collection && !collection.IsReadOnly)
			{
				collection.Clear();
			}
			else if (typeof(TCollection) == typeof(IEnumerable<T>))
			{
				values = Initialize(null, context);
			}
			else
			{
				ThrowInvalidCollectionType(values);
			}
			return values;
		}

		protected override TCollection AddRange(TCollection values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (!(values is List<T> list))
			{
				if (values is ICollection<T> collection && !collection.IsReadOnly)
				{
					Span<T> span = MemoryExtensions.AsSpan(newValues);
					for (int i = 0; i < span.Length; i++)
					{
						T item = span[i];
						collection.Add(item);
					}
				}
				else
				{
					ThrowInvalidCollectionType(values);
				}
			}
			else
			{
				list.AddRange(newValues);
			}
			return values;
		}
	}
	internal sealed class VectorSerializer<T> : RepeatedSerializer<T[], T>
	{
		[StructLayout(LayoutKind.Auto)]
		private struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
		{
			private readonly T[] _array;

			private int _index;

			public T Current => _array[_index];

			object IEnumerator.Current => _array[_index];

			public void Reset()
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			}

			public Enumerator(T[] array)
			{
				_array = array;
				_index = -1;
			}

			public bool MoveNext()
			{
				return ++_index < _array.Length;
			}

			public void Dispose()
			{
			}
		}

		protected override T[] Initialize(T[] values, ISerializationContext context)
		{
			return values ?? Array.Empty<T>();
		}

		protected override T[] Clear(T[] values, ISerializationContext context)
		{
			return Array.Empty<T>();
		}

		protected override T[] AddRange(T[] values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			T[] array = new T[values.Length + newValues.Count];
			Array.Copy(values, 0, array, 0, values.Length);
			Array.Copy(newValues.Array, newValues.Offset, array, values.Length, newValues.Count);
			return array;
		}

		protected override int TryGetCount(T[] values)
		{
			if (values != null)
			{
				return values.Length;
			}
			return 0;
		}

		internal override long Measure(T[] values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			return RepeatedSerializer<T[], T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void WritePacked(ref ProtoWriter.State state, T[] values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<T[], T>.WritePacked(ref state, ref values2, serializer, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, T[] values, ISerializer<T> serializer, SerializerFeatures features)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<T[], T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}
	}
	internal sealed class QueueSerializer<TCollection, T> : RepeatedSerializer<TCollection, T> where TCollection : Queue<T>
	{
		protected override TCollection Initialize(TCollection values, ISerializationContext context)
		{
			return values ?? TypeModel.ActivatorCreate<TCollection>();
		}

		protected override TCollection Clear(TCollection values, ISerializationContext context)
		{
			values.Clear();
			return values;
		}

		protected override int TryGetCount(TCollection values)
		{
			return values?.Count ?? 0;
		}

		protected override TCollection AddRange(TCollection values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T item = span[i];
				values.Enqueue(item);
			}
			return values;
		}

		internal override long Measure(TCollection values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			Queue<T>.Enumerator values2 = values.GetEnumerator();
			return RepeatedSerializer<TCollection, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void WritePacked(ref ProtoWriter.State state, TCollection values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			Queue<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<TCollection, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, TCollection values, ISerializer<T> serializer, SerializerFeatures features)
		{
			Queue<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<TCollection, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}
	}
	internal abstract class ExternalSerializer<TCollection, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T> : RepeatedSerializer<TCollection, T> where TCollection : IEnumerable<T>
	{
		internal override long Measure(TCollection values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			IEnumerator<T> values2 = null;
			try
			{
				values2 = values.GetEnumerator();
				return RepeatedSerializer<TCollection, T>.Measure(ref values2, serializer, context, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void WritePacked(ref ProtoWriter.State state, TCollection values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			IEnumerator<T> values2 = null;
			try
			{
				values2 = values.GetEnumerator();
				RepeatedSerializer<TCollection, T>.WritePacked(ref state, ref values2, serializer, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, TCollection values, ISerializer<T> serializer, SerializerFeatures features)
		{
			IEnumerator<T> values2 = null;
			try
			{
				values2 = values.GetEnumerator();
				RepeatedSerializer<TCollection, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
			}
			finally
			{
				values2?.Dispose();
			}
		}
	}
	internal sealed class ImmutableArraySerializer<T> : RepeatedSerializer<ImmutableArray<T>, T>
	{
		[StructLayout(LayoutKind.Auto)]
		private struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
		{
			private ImmutableArray<T>.Enumerator _iter;

			public T Current => _iter.Current;

			object IEnumerator.Current => _iter.Current;

			public void Reset()
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			}

			public Enumerator(ImmutableArray<T> array)
			{
				_iter = array.GetEnumerator();
			}

			public bool MoveNext()
			{
				return _iter.MoveNext();
			}

			public void Dispose()
			{
			}
		}

		protected override ImmutableArray<T> Initialize(ImmutableArray<T> values, ISerializationContext context)
		{
			if (!values.IsDefault)
			{
				return values;
			}
			return ImmutableArray<T>.Empty;
		}

		protected override ImmutableArray<T> Clear(ImmutableArray<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override ImmutableArray<T> AddRange(ImmutableArray<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count != 1)
			{
				return values.AddRange(new ReadOnlySpan<T>(newValues.Array, newValues.Offset, newValues.Count));
			}
			return values.Add(RepeatedSerializer.Singleton(ref newValues));
		}

		protected override int TryGetCount(ImmutableArray<T> values)
		{
			if (!values.IsEmpty)
			{
				return values.Length;
			}
			return 0;
		}

		internal override long Measure(ImmutableArray<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			return RepeatedSerializer<ImmutableArray<T>, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void WritePacked(ref ProtoWriter.State state, ImmutableArray<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<ImmutableArray<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ImmutableArray<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<ImmutableArray<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}
	}
	internal sealed class ImmutableListSerializer<T> : RepeatedSerializer<ImmutableList<T>, T>
	{
		protected override ImmutableList<T> Initialize(ImmutableList<T> values, ISerializationContext context)
		{
			return values ?? ImmutableList<T>.Empty;
		}

		protected override ImmutableList<T> AddRange(ImmutableList<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count != 1)
			{
				return values.AddRange(newValues);
			}
			return values.Add(RepeatedSerializer.Singleton(ref newValues));
		}

		protected override ImmutableList<T> Clear(ImmutableList<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(ImmutableList<T> values)
		{
			return values?.Count ?? 0;
		}

		internal override long Measure(ImmutableList<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			ImmutableList<T>.Enumerator values2 = values.GetEnumerator();
			return RepeatedSerializer<ImmutableList<T>, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ImmutableList<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			ImmutableList<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<ImmutableList<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}

		internal override void WritePacked(ref ProtoWriter.State state, ImmutableList<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			ImmutableList<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<ImmutableList<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}
	}
	internal sealed class ImmutableIListSerializer<T> : RepeatedSerializer<IImmutableList<T>, T>
	{
		protected override IImmutableList<T> Initialize(IImmutableList<T> values, ISerializationContext context)
		{
			return values ?? ImmutableList<T>.Empty;
		}

		protected override IImmutableList<T> AddRange(IImmutableList<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count != 1)
			{
				return values.AddRange(newValues);
			}
			return values.Add(RepeatedSerializer.Singleton(ref newValues));
		}

		protected override IImmutableList<T> Clear(IImmutableList<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(IImmutableList<T> values)
		{
			return TryGetCountDefault(values);
		}

		internal override long Measure(IImmutableList<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				return RepeatedSerializer<IImmutableList<T>, T>.Measure(ref values2, serializer, context, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, IImmutableList<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableList<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void WritePacked(ref ProtoWriter.State state, IImmutableList<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableList<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}
	}
	internal sealed class ImmutableHashSetSerializer<T> : RepeatedSerializer<ImmutableHashSet<T>, T>
	{
		protected override ImmutableHashSet<T> Initialize(ImmutableHashSet<T> values, ISerializationContext context)
		{
			return values ?? ImmutableHashSet<T>.Empty;
		}

		protected override ImmutableHashSet<T> AddRange(ImmutableHashSet<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count != 1)
			{
				return values.Union(newValues);
			}
			return values.Add(RepeatedSerializer.Singleton(ref newValues));
		}

		protected override ImmutableHashSet<T> Clear(ImmutableHashSet<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(ImmutableHashSet<T> values)
		{
			return values?.Count ?? 0;
		}

		internal override long Measure(ImmutableHashSet<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			ImmutableHashSet<T>.Enumerator values2 = values.GetEnumerator();
			return RepeatedSerializer<ImmutableHashSet<T>, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ImmutableHashSet<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			ImmutableHashSet<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<ImmutableHashSet<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}

		internal override void WritePacked(ref ProtoWriter.State state, ImmutableHashSet<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			ImmutableHashSet<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<ImmutableHashSet<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}
	}
	internal sealed class ImmutableSortedSetSerializer<T> : RepeatedSerializer<ImmutableSortedSet<T>, T>
	{
		protected override ImmutableSortedSet<T> Initialize(ImmutableSortedSet<T> values, ISerializationContext context)
		{
			return values ?? ImmutableSortedSet<T>.Empty;
		}

		protected override ImmutableSortedSet<T> AddRange(ImmutableSortedSet<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count != 1)
			{
				return values.Union(newValues);
			}
			return values.Add(RepeatedSerializer.Singleton(ref newValues));
		}

		protected override ImmutableSortedSet<T> Clear(ImmutableSortedSet<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(ImmutableSortedSet<T> values)
		{
			return values?.Count ?? 0;
		}

		internal override long Measure(ImmutableSortedSet<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			ImmutableSortedSet<T>.Enumerator values2 = values.GetEnumerator();
			return RepeatedSerializer<ImmutableSortedSet<T>, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ImmutableSortedSet<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			ImmutableSortedSet<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<ImmutableSortedSet<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}

		internal override void WritePacked(ref ProtoWriter.State state, ImmutableSortedSet<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			ImmutableSortedSet<T>.Enumerator values2 = values.GetEnumerator();
			RepeatedSerializer<ImmutableSortedSet<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}
	}
	internal sealed class ImmutableISetSerializer<T> : RepeatedSerializer<IImmutableSet<T>, T>
	{
		protected override IImmutableSet<T> Initialize(IImmutableSet<T> values, ISerializationContext context)
		{
			return values ?? ImmutableHashSet<T>.Empty;
		}

		protected override IImmutableSet<T> AddRange(IImmutableSet<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count != 1)
			{
				return values.Union(newValues);
			}
			return values.Add(RepeatedSerializer.Singleton(ref newValues));
		}

		protected override IImmutableSet<T> Clear(IImmutableSet<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(IImmutableSet<T> values)
		{
			return TryGetCountDefault(values);
		}

		internal override long Measure(IImmutableSet<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				return RepeatedSerializer<IImmutableSet<T>, T>.Measure(ref values2, serializer, context, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, IImmutableSet<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableSet<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void WritePacked(ref ProtoWriter.State state, IImmutableSet<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableSet<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}
	}
	internal sealed class ImmutableStackSerializer<T> : RepeatedSerializer<ImmutableStack<T>, T>
	{
		[StructLayout(LayoutKind.Auto)]
		private struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
		{
			private ImmutableStack<T>.Enumerator _iter;

			T IEnumerator<T>.Current => _iter.Current;

			object IEnumerator.Current => _iter.Current;

			public Enumerator(ImmutableStack<T> stack)
			{
				_iter = stack.GetEnumerator();
			}

			void IDisposable.Dispose()
			{
			}

			bool IEnumerator.MoveNext()
			{
				return _iter.MoveNext();
			}

			void IEnumerator.Reset()
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotImplementedException("Reset");
			}
		}

		protected override ImmutableStack<T> Initialize(ImmutableStack<T> values, ISerializationContext context)
		{
			return values ?? ImmutableStack<T>.Empty;
		}

		protected override ImmutableStack<T> AddRange(ImmutableStack<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				return values.Push(RepeatedSerializer.Singleton(ref newValues));
			}
			RepeatedSerializer.ReverseInPlace(ref newValues);
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T value = span[i];
				values = values.Push(value);
			}
			return values;
		}

		protected override ImmutableStack<T> Clear(ImmutableStack<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(ImmutableStack<T> values)
		{
			if (values != null && !values.IsEmpty)
			{
				return -1;
			}
			return 0;
		}

		internal override long Measure(ImmutableStack<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			return RepeatedSerializer<ImmutableStack<T>, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ImmutableStack<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<ImmutableStack<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}

		internal override void WritePacked(ref ProtoWriter.State state, ImmutableStack<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<ImmutableStack<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}
	}
	internal sealed class ImmutableIStackSerializer<T> : RepeatedSerializer<IImmutableStack<T>, T>
	{
		protected override IImmutableStack<T> Initialize(IImmutableStack<T> values, ISerializationContext context)
		{
			return values ?? ImmutableStack<T>.Empty;
		}

		protected override IImmutableStack<T> AddRange(IImmutableStack<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				return values.Push(RepeatedSerializer.Singleton(ref newValues));
			}
			RepeatedSerializer.ReverseInPlace(ref newValues);
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T value = span[i];
				values = values.Push(value);
			}
			return values;
		}

		protected override IImmutableStack<T> Clear(IImmutableStack<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(IImmutableStack<T> values)
		{
			try
			{
				return (values != null && !values.IsEmpty) ? (-1) : 0;
			}
			catch
			{
				return -1;
			}
		}

		internal override long Measure(IImmutableStack<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				return RepeatedSerializer<IImmutableStack<T>, T>.Measure(ref values2, serializer, context, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, IImmutableStack<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableStack<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void WritePacked(ref ProtoWriter.State state, IImmutableStack<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableStack<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}
	}
	internal sealed class ImmutableQueueSerializer<T> : RepeatedSerializer<ImmutableQueue<T>, T>
	{
		[StructLayout(LayoutKind.Auto)]
		private struct Enumerator : IEnumerator<T>, IDisposable, IEnumerator
		{
			private ImmutableQueue<T>.Enumerator _iter;

			T IEnumerator<T>.Current => _iter.Current;

			object IEnumerator.Current => _iter.Current;

			public Enumerator(ImmutableQueue<T> queue)
			{
				_iter = queue.GetEnumerator();
			}

			void IDisposable.Dispose()
			{
			}

			bool IEnumerator.MoveNext()
			{
				return _iter.MoveNext();
			}

			void IEnumerator.Reset()
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotImplementedException("Reset");
			}
		}

		protected override ImmutableQueue<T> Initialize(ImmutableQueue<T> values, ISerializationContext context)
		{
			return values ?? ImmutableQueue<T>.Empty;
		}

		protected override ImmutableQueue<T> AddRange(ImmutableQueue<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				return values.Enqueue(RepeatedSerializer.Singleton(ref newValues));
			}
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T value = span[i];
				values = values.Enqueue(value);
			}
			return values;
		}

		protected override ImmutableQueue<T> Clear(ImmutableQueue<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(ImmutableQueue<T> values)
		{
			if (values != null && !values.IsEmpty)
			{
				return -1;
			}
			return 0;
		}

		internal override long Measure(ImmutableQueue<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			return RepeatedSerializer<ImmutableQueue<T>, T>.Measure(ref values2, serializer, context, wireType);
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, ImmutableQueue<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<ImmutableQueue<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
		}

		internal override void WritePacked(ref ProtoWriter.State state, ImmutableQueue<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			Enumerator values2 = new Enumerator(values);
			RepeatedSerializer<ImmutableQueue<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
		}
	}
	internal sealed class ImmutableIQueueSerializer<T> : RepeatedSerializer<IImmutableQueue<T>, T>
	{
		protected override IImmutableQueue<T> Initialize(IImmutableQueue<T> values, ISerializationContext context)
		{
			return values ?? ImmutableQueue<T>.Empty;
		}

		protected override IImmutableQueue<T> AddRange(IImmutableQueue<T> values, ref ArraySegment<T> newValues, ISerializationContext context)
		{
			if (newValues.Count == 1)
			{
				return values.Enqueue(RepeatedSerializer.Singleton(ref newValues));
			}
			Span<T> span = MemoryExtensions.AsSpan(newValues);
			for (int i = 0; i < span.Length; i++)
			{
				T value = span[i];
				values = values.Enqueue(value);
			}
			return values;
		}

		protected override IImmutableQueue<T> Clear(IImmutableQueue<T> values, ISerializationContext context)
		{
			return values.Clear();
		}

		protected override int TryGetCount(IImmutableQueue<T> values)
		{
			try
			{
				return (values != null && !values.IsEmpty) ? (-1) : 0;
			}
			catch
			{
				return -1;
			}
		}

		internal override long Measure(IImmutableQueue<T> values, IMeasuringSerializer<T> serializer, ISerializationContext context, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				return RepeatedSerializer<IImmutableQueue<T>, T>.Measure(ref values2, serializer, context, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void Write(ref ProtoWriter.State state, int fieldNumber, SerializerFeatures category, WireType wireType, IImmutableQueue<T> values, ISerializer<T> serializer, SerializerFeatures features)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableQueue<T>, T>.Write(ref state, fieldNumber, category, wireType, ref values2, serializer, features);
			}
			finally
			{
				values2?.Dispose();
			}
		}

		internal override void WritePacked(ref ProtoWriter.State state, IImmutableQueue<T> values, IMeasuringSerializer<T> serializer, WireType wireType)
		{
			IEnumerator<T> values2 = values.GetEnumerator();
			try
			{
				RepeatedSerializer<IImmutableQueue<T>, T>.WritePacked(ref state, ref values2, serializer, wireType);
			}
			finally
			{
				values2?.Dispose();
			}
		}
	}
	internal static class SerializerCache<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicMethods)] TProvider> where TProvider : class
	{
		internal static readonly TProvider InstanceField = (TProvider)Activator.CreateInstance(typeof(TProvider), nonPublic: true);

		public static ISerializer<T> GetSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return SerializerCache<TProvider, T>.InstanceField;
		}
	}
	internal static class SerializerCache<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicMethods)] TProvider, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T> where TProvider : class
	{
		internal static readonly ISerializer<T> InstanceField = SerializerCache.Verify((SerializerCache<TProvider>.InstanceField as ISerializer<T>) ?? (SerializerCache<TProvider>.InstanceField as ISerializerProxy<T>)?.Serializer);

		public static ISerializer<T> Instance
		{
			[MethodImpl(MethodImplOptions.AggressiveInlining)]
			get
			{
				return InstanceField;
			}
		}
	}
	internal static class SerializerCache
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		private static void ThrowInvalidSerializer<T>(ISerializer<T> serializer, string message, Exception innerException = null)
		{
			string text = typeof(T).NormalizeName();
			string text2 = serializer.GetType().NormalizeName();
			string text3 = serializer.Features.ToString();
			try
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The serializer " + text2 + " for type " + text + " has invalid features: " + message + " (" + text3 + ")", innerException);
			}
			catch (InvalidOperationException ex)
			{
				ex.Data.Add("type", text);
				ex.Data.Add("serializer", text2);
				ex.Data.Add("features", text3);
				throw;
			}
		}

		internal static ISerializer<T> Verify<T>(ISerializer<T> serializer)
		{
			if (serializer == null)
			{
				return null;
			}
			try
			{
				SerializerFeatures features = serializer.Features;
				if (serializer is IRepeatedSerializer<T>)
				{
					if (((uint)features & 0xFFFFFFFFu) != 0)
					{
						ThrowInvalidSerializer(serializer, $"repeated serializers may only specify {SerializerFeatures.CategoryRepeated}");
					}
					return serializer;
				}
				WireType wireType = features.GetWireType();
				switch (wireType)
				{
				default:
					ThrowInvalidSerializer(serializer, $"invalid wire-type {wireType}");
					break;
				case WireType.Variant:
				case WireType.Fixed64:
				case WireType.String:
				case WireType.StartGroup:
				case WireType.Fixed32:
				case WireType.SignedVariant:
					break;
				}
				switch (features.GetCategory())
				{
				case SerializerFeatures.CategoryMessage:
				case SerializerFeatures.CategoryMessageWrappedAtRoot:
					if (TypeHelper<T>.CanBePacked)
					{
						ThrowInvalidSerializer(serializer, "message serializer specified for a type that can be 'packed'");
					}
					break;
				case SerializerFeatures.CategoryScalar:
					if (TypeHelper<T>.CanBePacked && (uint)wireType > 1u && wireType != WireType.Fixed32 && wireType != WireType.SignedVariant)
					{
						ThrowInvalidSerializer(serializer, "invalid wire-type for a type that can be 'packed'");
					}
					break;
				default:
					features.ThrowInvalidCategory();
					break;
				}
				if ((features & (SerializerFeatures.OptionPackedDisabled | SerializerFeatures.OptionClearCollection)) != 0)
				{
					ThrowInvalidSerializer(serializer, $"serializers should not specify {SerializerFeatures.OptionPackedDisabled | SerializerFeatures.OptionClearCollection}");
				}
				return serializer;
			}
			catch (InvalidOperationException ex) when (!ex.Data.Contains("serializer"))
			{
				ThrowInvalidSerializer(serializer, ex.Message, ex);
				throw;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ISerializer<T> Get<TProvider, T>() where TProvider : class
		{
			return SerializerCache<TProvider, T>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static object GetInstance(Type providerType, Type type)
		{
			return typeof(SerializerCache<, >).MakeGenericType(providerType, type).GetField("InstanceField", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).GetValue(null);
		}
	}
}
namespace ProtoBuf.Meta
{
	internal enum ProtoSyntax
	{
		Default = -1,
		Proto2,
		Proto3
	}
	internal sealed class SchemaGenerationOptions
	{
		internal static readonly SchemaGenerationOptions Default = new SchemaGenerationOptions();

		private List<Service> _services;

		private List<Type> _types;

		public ProtoSyntax Syntax { get; set; } = ProtoSyntax.Default;


		public SchemaGenerationFlags Flags { get; set; }

		public string Package { get; set; }

		public List<Service> Services => _services ?? (_services = new List<Service>());

		public List<Type> Types => _types ?? (_types = new List<Type>());

		internal bool HasServices => (_services?.Count ?? 0) != 0;

		internal bool HasTypes => (_types?.Count ?? 0) != 0;

		public string Origin { get; set; }
	}
	[Flags]
	internal enum SchemaGenerationFlags
	{
		None = 0,
		MultipleNamespaceSupport = 1,
		PreserveSubType = 2
	}
	internal sealed class Service
	{
		public string Name { get; set; }

		public List<ServiceMethod> Methods { get; } = new List<ServiceMethod>();

	}
	internal sealed class ServiceMethod
	{
		public string Name { get; set; }

		public Type InputType { get; set; } = typeof(Empty);


		public Type OutputType { get; set; } = typeof(Empty);


		public bool ServerStreaming { get; set; }

		public bool ClientStreaming { get; set; }
	}
	internal class TypeFormatEventArgs : EventArgs
	{
		private Type type;

		private string formattedName;

		private readonly bool typeFixed;

		public Type Type
		{
			get
			{
				return type;
			}
			set
			{
				if (type != value)
				{
					if (typeFixed)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The type is fixed and cannot be changed");
					}
					type = value;
				}
			}
		}

		public string FormattedName
		{
			get
			{
				return formattedName;
			}
			set
			{
				if (formattedName != value)
				{
					if (!typeFixed)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("The formatted-name is fixed and cannot be changed");
					}
					formattedName = value;
				}
			}
		}

		internal TypeFormatEventArgs(string formattedName)
		{
			if (string.IsNullOrEmpty(formattedName))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("formattedName");
			}
			this.formattedName = formattedName;
		}

		internal TypeFormatEventArgs(Type type)
		{
			if ((object)type == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("type");
			}
			this.type = type;
			typeFixed = true;
		}
	}
	internal delegate void TypeFormatEventHandler(object sender, TypeFormatEventArgs args);
	internal static class TypeModelExtensions
	{
		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool HasOption(this TypeModel model, TypeModel.TypeModelOptions options)
		{
			TypeModel.TypeModelOptions typeModelOptions = model?.Options ?? TypeModel.TypeModelOptions.None;
			return (typeModelOptions & options) != 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool OmitsOption(this TypeModel model, TypeModel.TypeModelOptions options)
		{
			TypeModel.TypeModelOptions typeModelOptions = model?.Options ?? TypeModel.TypeModelOptions.None;
			return (typeModelOptions & options) == 0;
		}
	}
	internal abstract class TypeModel : IProtoInput<Stream>, IProtoInput<ArraySegment<byte>>, IProtoInput<byte[]>, IProtoInput<ReadOnlyMemory<byte>>, IProtoInput<ReadOnlySequence<byte>>, IProtoOutput<Stream>, IProtoOutput<IBufferWriter<byte>>, IMeasuredProtoOutput<Stream>, IMeasuredProtoOutput<IBufferWriter<byte>>
	{
		[Flags]
		public enum TypeModelOptions
		{
			None = 0,
			InternStrings = 1,
			IncludeDateTimeKind = 2,
			SkipZeroLengthPackedArrays = 4,
			AllowPackedEncodingAtRoot = 8
		}

		private sealed class DeserializeItemsIterator<T> : DeserializeItemsIterator, IEnumerator<T>, IDisposable, IEnumerator, IEnumerable<T>, IEnumerable
		{
			public new T Current => (T)base.Current;

			IEnumerator<T> IEnumerable<T>.GetEnumerator()
			{
				return this;
			}

			void IDisposable.Dispose()
			{
			}

			public DeserializeItemsIterator(TypeModel model, Stream source, PrefixStyle style, int expectedField, SerializationContext context)
				: base(model, source, typeof(T), style, expectedField, null, context)
			{
			}
		}

		private class DeserializeItemsIterator : IEnumerator, IEnumerable
		{
			private bool haveObject;

			private object current;

			private readonly Stream source;

			private readonly Type type;

			private readonly PrefixStyle style;

			private readonly int expectedField;

			private readonly TypeResolver resolver;

			private readonly TypeModel model;

			private readonly SerializationContext context;

			public object Current => current;

			IEnumerator IEnumerable.GetEnumerator()
			{
				return this;
			}

			public bool MoveNext()
			{
				if (haveObject)
				{
					current = model.DeserializeWithLengthPrefix(source, null, type, style, expectedField, resolver, out var _, out haveObject, context);
				}
				return haveObject;
			}

			void IEnumerator.Reset()
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			}

			public DeserializeItemsIterator(TypeModel model, Stream source, Type type, PrefixStyle style, int expectedField, TypeResolver resolver, SerializationContext context)
			{
				haveObject = true;
				this.source = source;
				this.type = type;
				this.style = style;
				this.expectedField = expectedField;
				this.resolver = resolver;
				this.model = model;
				this.context = context;
			}
		}

		internal sealed class NullModel : TypeModel
		{
			private static readonly NullModel s_Singleton = new NullModel();

			public static TypeModel Singleton
			{
				[MethodImpl(MethodImplOptions.NoInlining)]
				get
				{
					return s_Singleton;
				}
			}

			private NullModel()
			{
			}

			protected override ISerializer<T> GetSerializer<T>()
			{
				return null;
			}
		}

		protected internal enum CallbackType
		{
			BeforeSerialize,
			AfterSerialize,
			BeforeDeserialize,
			AfterDeserialize
		}

		internal sealed class Formatter : IFormatter
		{
			private readonly TypeModel model;

			private readonly Type type;

			public SerializationBinder Binder { get; set; }

			public StreamingContext Context { get; set; }

			public ISurrogateSelector SurrogateSelector { get; set; }

			internal Formatter(TypeModel model, Type type)
			{
				if (model == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("model");
				}
				if ((object)type == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("model");
				}
				this.model = model;
				this.type = type;
			}

			public object Deserialize(Stream serializationStream)
			{
				using ProtoReader.State state = ProtoReader.State.Create(serializationStream, model, Context, -1L);
				return state.DeserializeRootFallback(null, type);
			}

			public void Serialize(Stream serializationStream, object graph)
			{
				ProtoWriter.State state = ProtoWriter.State.Create(serializationStream, model, Context);
				try
				{
					model.SerializeRootFallback(ref state, graph);
				}
				finally
				{
					state.Dispose();
				}
			}
		}

		private int _bufferSize = 1024;

		private int _maxDepth = 512;

		internal const int DefaultMaxDepth = 512;

		internal const TypeModelOptions DefaultOptions = TypeModelOptions.None;

		internal const SerializerFeatures FromAux = (SerializerFeatures)1073741824;

		private static TypeModel s_defaultModel;

		public const int ListItemTag = 1;

		public int BufferSize
		{
			get
			{
				return _bufferSize;
			}
			set
			{
				_bufferSize = ((value <= 0) ? 1024 : value);
			}
		}

		public int MaxDepth
		{
			get
			{
				return _maxDepth;
			}
			set
			{
				_maxDepth = ((value <= 0) ? 512 : value);
			}
		}

		public virtual TypeModelOptions Options => TypeModelOptions.None;

		internal static TypeModel DefaultModel => s_defaultModel ?? SetDefaultModel(null);

		public event TypeFormatEventHandler DynamicTypeFormatting;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		protected static ISerializer<T> GetSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicMethods)] TProvider, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>() where TProvider : class
		{
			return SerializerCache<TProvider, T>.InstanceField;
		}

		[Obsolete("This API is no longer required and may be removed in a future release")]
		protected internal Type MapType(Type type)
		{
			return type;
		}

		[Obsolete("This API is no longer required and may be removed in a future release")]
		protected internal Type MapType(Type type, bool demand)
		{
			return type;
		}

		internal static WireType GetWireType(TypeModel model, DataFormat format, Type type)
		{
			if (type.IsEnum)
			{
				return WireType.Variant;
			}
			if (model != null && model.CanSerializeContractType(type))
			{
				if (format != DataFormat.Group)
				{
					return WireType.String;
				}
				return WireType.StartGroup;
			}
			switch (Helpers.GetTypeCode(type))
			{
			case ProtoTypeCode.Int64:
			case ProtoTypeCode.UInt64:
				if (format != DataFormat.FixedSize)
				{
					return WireType.Variant;
				}
				return WireType.Fixed64;
			case ProtoTypeCode.Boolean:
			case ProtoTypeCode.Char:
			case ProtoTypeCode.SByte:
			case ProtoTypeCode.Byte:
			case ProtoTypeCode.Int16:
			case ProtoTypeCode.UInt16:
			case ProtoTypeCode.Int32:
			case ProtoTypeCode.UInt32:
				if (format != DataFormat.FixedSize)
				{
					return WireType.Variant;
				}
				return WireType.Fixed32;
			case ProtoTypeCode.Double:
				return WireType.Fixed64;
			case ProtoTypeCode.Single:
				return WireType.Fixed32;
			case ProtoTypeCode.Decimal:
			case ProtoTypeCode.DateTime:
			case ProtoTypeCode.String:
			case ProtoTypeCode.TimeSpan:
			case ProtoTypeCode.ByteArray:
			case ProtoTypeCode.Guid:
			case ProtoTypeCode.Uri:
			case ProtoTypeCode.ByteArraySegment:
			case ProtoTypeCode.ByteMemory:
			case ProtoTypeCode.ByteReadOnlyMemory:
				return WireType.String;
			default:
				return WireType.None;
			}
		}

		internal virtual bool IsKnownType<T>(CompatibilityLevel ambient)
		{
			if (TypeHelper<T>.IsReferenceType | !TypeHelper<T>.CanBeNull)
			{
				return GetSerializerCore<T>(ambient) != null;
			}
			return false;
		}

		internal bool TrySerializeAuxiliaryType(ref ProtoWriter.State state, Type type, DataFormat format, int tag, object value, bool isInsideList, object parentList, bool isRoot)
		{
			PrepareDeserialize(value, ref type);
			WireType wireType = GetWireType(this, format, type);
			if (DynamicStub.CanSerialize(type, this, out var features))
			{
				ObjectScope objectScope = NormalizeAuxScope(features, isInsideList, type, isRoot);
				try
				{
					if (!DynamicStub.TrySerializeAny(tag, wireType.AsFeatures() | (SerializerFeatures)1073741824, type, this, ref state, value))
					{
						ThrowUnexpectedType(type, this);
					}
				}
				catch (Exception ex)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowProtoException(ex.Message + $"; scope: {objectScope}, features: {features}; type: {type.NormalizeName()}", ex);
				}
				return true;
			}
			if (value is IEnumerable enumerable)
			{
				if (isInsideList)
				{
					ThrowNestedListsNotSupported(parentList?.GetType());
				}
				foreach (object item in enumerable)
				{
					if (item == null)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowNullReferenceException();
					}
					if (!TrySerializeAuxiliaryType(ref state, null, format, tag, item, isInsideList: true, enumerable, isRoot))
					{
						ThrowUnexpectedType(item.GetType(), this);
					}
				}
				return true;
			}
			return false;
		}

		private static ObjectScope NormalizeAuxScope(SerializerFeatures features, bool isInsideList, Type type, bool isRoot)
		{
			switch (features.GetCategory())
			{
			case SerializerFeatures.CategoryRepeated:
				if (isInsideList)
				{
					ThrowNestedListsNotSupported(type);
				}
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException("A repeated type was not expected as an aux type: " + type.NormalizeName());
				return ObjectScope.NakedMessage;
			case SerializerFeatures.CategoryMessage:
				return ObjectScope.WrappedMessage;
			case SerializerFeatures.CategoryMessageWrappedAtRoot:
				if (!(isInsideList || isRoot))
				{
					return ObjectScope.LikeRoot;
				}
				return ObjectScope.WrappedMessage;
			case SerializerFeatures.CategoryScalar:
				return ObjectScope.Scalar;
			default:
				features.ThrowInvalidCategory();
				return ObjectScope.Invalid;
			}
		}

		public void Serialize(Stream dest, object value)
		{
			ProtoWriter.State state = ProtoWriter.State.Create(dest, this);
			try
			{
				SerializeRootFallback(ref state, value);
			}
			finally
			{
				state.Dispose();
			}
		}

		public void Serialize(Stream dest, object value, SerializationContext context)
		{
			ProtoWriter.State state = ProtoWriter.State.Create(dest, this, context);
			try
			{
				SerializeRootFallback(ref state, value);
			}
			finally
			{
				state.Dispose();
			}
		}

		public void Serialize(IBufferWriter<byte> dest, object value, object userState = null)
		{
			ProtoWriter.State state = ProtoWriter.State.Create(dest, this, userState);
			try
			{
				SerializeRootFallback(ref state, value);
			}
			finally
			{
				state.Dispose();
			}
		}

		internal void SerializeRootFallback(ref ProtoWriter.State state, object value)
		{
			Type type = value.GetType();
			try
			{
				if (!DynamicStub.TrySerializeRoot(type, this, ref state, value))
				{
					if (!TrySerializeAuxiliaryType(ref state, type, DataFormat.Default, 1, value, isInsideList: false, null, isRoot: true))
					{
						ThrowUnexpectedType(type, this);
					}
					state.Close();
				}
			}
			catch
			{
				state.Abandon();
				throw;
			}
		}

		public long Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream dest, T value, object userState = null)
		{
			ProtoWriter.State state = ProtoWriter.State.Create(dest, this, userState);
			try
			{
				return SerializeImpl(ref state, value);
			}
			finally
			{
				state.Dispose();
			}
		}

		public long Serialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(IBufferWriter<byte> dest, T value, object userState = null)
		{
			ProtoWriter.State state = ProtoWriter.State.Create(dest, this, userState);
			try
			{
				return SerializeImpl(ref state, value);
			}
			finally
			{
				state.Dispose();
			}
		}

		public MeasureState<T> Measure<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value, object userState = null, long abortAfter = -1L)
		{
			return new MeasureState<T>(this, in value, userState, abortAfter);
		}

		[Obsolete("If possible, please use the State API; a transitionary implementation is provided, but this API may be removed in a future version", false)]
		public void Serialize(ProtoWriter dest, object value)
		{
			ProtoWriter.State state = dest.DefaultState();
			SerializeRootFallback(ref state, value);
		}

		internal static long SerializeImpl<T>(ref ProtoWriter.State state, T value)
		{
			if (TypeHelper<T>.CanBeNull && TypeHelper<T>.ValueChecker.IsNull(value))
			{
				return 0L;
			}
			ISerializer<T> serializer = TryGetSerializer<T>(state.Model);
			if (serializer == null)
			{
				long position = state.GetPosition();
				state.Model.SerializeRootFallback(ref state, value);
				return state.GetPosition() - position;
			}
			return state.SerializeRoot(value, serializer);
		}

		public object DeserializeWithLengthPrefix(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int fieldNumber)
		{
			long bytesRead;
			return DeserializeWithLengthPrefix(source, value, type, style, fieldNumber, (TypeResolver)null, out bytesRead);
		}

		public object DeserializeWithLengthPrefix(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int expectedField, TypeResolver resolver)
		{
			long bytesRead;
			return DeserializeWithLengthPrefix(source, value, type, style, expectedField, resolver, out bytesRead);
		}

		public object DeserializeWithLengthPrefix(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int expectedField, TypeResolver resolver, out int bytesRead)
		{
			long bytesRead2;
			bool haveObject;
			object result = DeserializeWithLengthPrefix(source, value, type, style, expectedField, resolver, out bytesRead2, out haveObject, null);
			bytesRead = checked((int)bytesRead2);
			return result;
		}

		public object DeserializeWithLengthPrefix(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int expectedField, TypeResolver resolver, out long bytesRead)
		{
			bool haveObject;
			return DeserializeWithLengthPrefix(source, value, type, style, expectedField, resolver, out bytesRead, out haveObject, null);
		}

		private object DeserializeWithLengthPrefix(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int expectedField, TypeResolver resolver, out long bytesRead, out bool haveObject, SerializationContext context)
		{
			haveObject = false;
			bytesRead = 0L;
			if ((object)type == null && (style != PrefixStyle.Base128 || resolver == null))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("A type must be provided unless base-128 prefixing is being used in combination with a resolver");
			}
			long num;
			bool flag2;
			do
			{
				bool flag = expectedField > 0 || resolver != null;
				num = ProtoReader.ReadLongLengthPrefix(source, flag, style, out var fieldNumber, out var bytesRead2);
				if (bytesRead2 == 0)
				{
					return value;
				}
				bytesRead += bytesRead2;
				if (num < 0)
				{
					return value;
				}
				if (style == PrefixStyle.Base128)
				{
					if (flag && expectedField == 0 && (object)type == null && resolver != null)
					{
						type = resolver(fieldNumber);
						flag2 = (object)type == null;
					}
					else
					{
						flag2 = expectedField != fieldNumber;
					}
				}
				else
				{
					flag2 = false;
				}
				if (flag2)
				{
					if (num == long.MaxValue)
					{
						ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException();
					}
					ProtoReader.Seek(source, num, null);
					bytesRead += num;
				}
			}
			while (flag2);
			ProtoReader.State state = ProtoReader.State.Create(source, this, context, num);
			try
			{
				if (IsDefined(type) && !type.IsEnum)
				{
					value = Deserialize(ObjectScope.LikeRoot, ref state, type, value);
				}
				else if (!TryDeserializeAuxiliaryType(ref state, DataFormat.Default, 1, type, ref value, skipOtherFields: true, asListItem: false, autoCreate: true, insideList: false, null, isRoot: true) && num != 0L)
				{
					ThrowUnexpectedType(type, this);
				}
				bytesRead += state.GetPosition();
			}
			finally
			{
				state.Dispose();
			}
			haveObject = true;
			return value;
		}

		public IEnumerable DeserializeItems(Stream source, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int expectedField, TypeResolver resolver)
		{
			return DeserializeItems(source, type, style, expectedField, resolver, null);
		}

		public IEnumerable DeserializeItems(Stream source, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int expectedField, TypeResolver resolver, SerializationContext context)
		{
			return new DeserializeItemsIterator(this, source, type, style, expectedField, resolver, context);
		}

		public IEnumerable<T> DeserializeItems<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, PrefixStyle style, int expectedField)
		{
			return DeserializeItems<T>(source, style, expectedField, null);
		}

		public IEnumerable<T> DeserializeItems<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, PrefixStyle style, int expectedField, SerializationContext context)
		{
			return new DeserializeItemsIterator<T>(this, source, style, expectedField, context);
		}

		public void SerializeWithLengthPrefix(Stream dest, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int fieldNumber)
		{
			SerializeWithLengthPrefix(dest, value, type, style, fieldNumber, null);
		}

		public void SerializeWithLengthPrefix(Stream dest, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, PrefixStyle style, int fieldNumber, SerializationContext context)
		{
			if ((object)type == null)
			{
				if (value == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("value");
				}
				type = value.GetType();
			}
			ProtoWriter.State state = ProtoWriter.State.Create(dest, this, context);
			try
			{
				switch (style)
				{
				case PrefixStyle.None:
					if (!DynamicStub.TrySerializeRoot(type, this, ref state, value))
					{
						ThrowUnexpectedType(type, this);
					}
					break;
				case PrefixStyle.Base128:
				case PrefixStyle.Fixed32:
				case PrefixStyle.Fixed32BigEndian:
					state.WriteObject(value, type, style, fieldNumber);
					break;
				default:
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentOutOfRangeException("style");
					break;
				}
				state.Flush();
				state.Close();
			}
			catch
			{
				state.Abandon();
				throw;
			}
			finally
			{
				state.Dispose();
			}
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Browsable(false)]
		public object Deserialize(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, null, -1L);
			return state.DeserializeRootFallback(value, type);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Browsable(false)]
		public object Deserialize(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, SerializationContext context)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, context, -1L);
			return state.DeserializeRootFallback(value, type);
		}

		public T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(Stream source, T value = default(T), object userState = null)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, userState, -1L);
			return state.DeserializeRootImpl(value);
		}

		public T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ReadOnlyMemory<byte> source, T value = default(T), object userState = null)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, userState);
			return state.DeserializeRootImpl(value);
		}

		public unsafe T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ReadOnlySpan<byte> source, T value = default(T), object userState = null)
		{
			fixed (byte* pointer = source)
			{
				FixedMemoryManager fixedMemoryManager = null;
				ProtoReader.State state = default(ProtoReader.State);
				try
				{
					fixedMemoryManager = Pool<FixedMemoryManager>.TryGet() ?? new FixedMemoryManager();
					state = ProtoReader.State.Create(fixedMemoryManager.Init(pointer, source.Length), this, userState);
					return state.DeserializeRootImpl(value);
				}
				finally
				{
					state.Dispose();
					Pool<FixedMemoryManager>.Put(fixedMemoryManager);
				}
			}
		}

		public T Deserialize<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(ReadOnlySequence<byte> source, T value = default(T), object userState = null)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, userState);
			return state.DeserializeRootImpl(value);
		}

		public object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, Stream source, object value = null, object userState = null, long length = -1L)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, userState, length);
			return state.DeserializeRootFallback(value, type);
		}

		public object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ReadOnlyMemory<byte> source, object value = null, object userState = null)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, userState);
			return state.DeserializeRootFallback(value, type);
		}

		public unsafe object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ReadOnlySpan<byte> source, object value = null, object userState = null)
		{
			fixed (byte* pointer = source)
			{
				FixedMemoryManager fixedMemoryManager = null;
				ProtoReader.State state = default(ProtoReader.State);
				try
				{
					fixedMemoryManager = Pool<FixedMemoryManager>.TryGet() ?? new FixedMemoryManager();
					state = ProtoReader.State.Create(fixedMemoryManager.Init(pointer, source.Length), this, userState);
					return state.DeserializeRootFallback(value, type);
				}
				finally
				{
					state.Dispose();
					Pool<FixedMemoryManager>.Put(fixedMemoryManager);
				}
			}
		}

		public object Deserialize([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ReadOnlySequence<byte> source, object value = null, object userState = null)
		{
			using ProtoReader.State state = ProtoReader.State.Create(source, this, userState);
			return state.DeserializeRootFallback(value, type);
		}

		internal static bool PrepareDeserialize(object value, ref Type type)
		{
			if ((object)type == null || type == typeof(object))
			{
				if (value == null)
				{
					ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("type");
				}
				type = value.GetType();
			}
			bool result = true;
			Type underlyingType = Nullable.GetUnderlyingType(type);
			if ((object)underlyingType == null)
			{
				type = DynamicStub.GetEffectiveType(type);
			}
			else
			{
				type = underlyingType;
				result = false;
			}
			return result;
		}

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public object Deserialize(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, int length)
		{
			return Deserialize(source, value, type, length, null);
		}

		[Browsable(false)]
		[EditorBrowsable(EditorBrowsableState.Never)]
		public object Deserialize(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, long length)
		{
			return Deserialize(source, value, type, length, null);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Browsable(false)]
		public object Deserialize(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, int length, SerializationContext context)
		{
			return Deserialize(source, value, type, (length == int.MaxValue) ? long.MaxValue : length, context);
		}

		[EditorBrowsable(EditorBrowsableState.Never)]
		[Browsable(false)]
		public object Deserialize(Stream source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, long length, SerializationContext context)
		{
			ProtoReader.State state = ProtoReader.State.Create(source, this, context, length);
			try
			{
				bool autoCreate = PrepareDeserialize(value, ref type);
				if (!DynamicStub.TryDeserializeRoot(type, this, ref state, ref value, autoCreate))
				{
					value = state.DeserializeRootFallback(value, type);
				}
				return value;
			}
			finally
			{
				state.Dispose();
			}
		}

		public object Deserialize(ReadOnlyMemory<byte> source, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, object value = null, object userState = null)
		{
			ProtoReader.State state = ProtoReader.State.Create(source, this, userState);
			try
			{
				bool autoCreate = PrepareDeserialize(value, ref type);
				if (!DynamicStub.TryDeserializeRoot(type, this, ref state, ref value, autoCreate))
				{
					value = state.DeserializeRootFallback(value, type);
				}
				return value;
			}
			finally
			{
				state.Dispose();
			}
		}

		public object Deserialize(ReadOnlySequence<byte> source, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, object value = null, object userState = null)
		{
			ProtoReader.State state = ProtoReader.State.Create(source, this, userState);
			try
			{
				bool autoCreate = PrepareDeserialize(value, ref type);
				if (!DynamicStub.TryDeserializeRoot(type, this, ref state, ref value, autoCreate))
				{
					value = state.DeserializeRootFallback(value, type);
				}
				return value;
			}
			finally
			{
				state.Dispose();
			}
		}

		[Obsolete("If possible, please use the State API; a transitionary implementation is provided, but this API may be removed in a future version", false)]
		public object Deserialize(ProtoReader source, object value, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type)
		{
			return source.DefaultState().DeserializeRootFallbackWithModel(value, type, this);
		}

		internal object DeserializeRootAny(ref ProtoReader.State state, [DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, object value, bool autoCreate)
		{
			if (!DynamicStub.TryDeserializeRoot(type, this, ref state, ref value, autoCreate))
			{
				TryDeserializeAuxiliaryType(ref state, DataFormat.Default, 1, type, ref value, skipOtherFields: true, asListItem: false, autoCreate, insideList: false, null, isRoot: true);
			}
			return value;
		}

		private bool TryDeserializeList(ref ProtoReader.State state, DataFormat format, int tag, Type listType, Type itemType, ref object value, bool isRoot)
		{
			bool result = false;
			object value2 = null;
			IList list = value as IList;
			IList list2 = ((list == null) ? ((IList)Activator.CreateInstance(typeof(List<>).MakeGenericType(itemType), nonPublic: true)) : null);
			while (TryDeserializeAuxiliaryType(ref state, format, tag, itemType, ref value2, skipOtherFields: true, asListItem: true, autoCreate: true, insideList: true, value ?? listType, isRoot))
			{
				result = true;
				if (value == null && list2 == null)
				{
					value = CreateListInstance(listType, itemType);
					list = value as IList;
				}
				if (list != null)
				{
					list.Add(value2);
				}
				else
				{
					list2.Add(value2);
				}
				value2 = null;
			}
			if (list2 != null)
			{
				if (value != null)
				{
					if (list2.Count != 0)
					{
						Array array = (Array)value;
						Array array2 = Array.CreateInstance(itemType, array.Length + list2.Count);
						Array.Copy(array, array2, array.Length);
						list2.CopyTo(array2, array.Length);
						value = array2;
					}
				}
				else
				{
					Array array2 = Array.CreateInstance(itemType, list2.Count);
					list2.CopyTo(array2, 0);
					value = array2;
				}
			}
			return result;
		}

		private static object CreateListInstance(Type listType, Type itemType)
		{
			Type type = listType;
			if (listType.IsArray)
			{
				return Array.CreateInstance(itemType, 0);
			}
			if (!listType.IsClass || listType.IsAbstract || (object)Helpers.GetConstructor(listType, Type.EmptyTypes, nonPublic: true) == null)
			{
				bool flag = false;
				string fullName;
				if (listType.IsInterface && (fullName = listType.FullName) != null && fullName.Contains("Dictionary"))
				{
					if (listType.IsGenericType && listType.GetGenericTypeDefinition() == typeof(IDictionary<, >))
					{
						Type[] genericArguments = listType.GetGenericArguments();
						type = typeof(Dictionary<, >).MakeGenericType(genericArguments);
						flag = true;
					}
					if (!flag && listType == typeof(IDictionary))
					{
						type = typeof(Hashtable);
						flag = true;
					}
				}
				if (!flag)
				{
					type = typeof(List<>).MakeGenericType(itemType);
					flag = true;
				}
				if (!flag)
				{
					type = typeof(ArrayList);
					flag = true;
				}
			}
			return Activator.CreateInstance(type, nonPublic: true);
		}

		internal bool TryDeserializeAuxiliaryType(ref ProtoReader.SolidState state, DataFormat format, int tag, Type type, ref object value, bool skipOtherFields, bool asListItem, bool autoCreate, bool insideList, object parentListOrType, bool isRoot)
		{
			ProtoReader.State state2 = state.Liquify();
			bool result = TryDeserializeAuxiliaryType(ref state2, format, tag, type, ref value, skipOtherFields, asListItem, autoCreate, insideList, parentListOrType, isRoot);
			state = state2.Solidify();
			return result;
		}

		internal bool TryDeserializeAuxiliaryType(ref ProtoReader.State state, DataFormat format, int tag, Type type, ref object value, bool skipOtherFields, bool asListItem, bool autoCreate, bool insideList, object parentListOrType, bool isRoot)
		{
			if ((object)type == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("type");
			}
			WireType wireType = GetWireType(this, format, type);
			bool flag = false;
			if (wireType == WireType.None)
			{
				if (!TypeHelper.ResolveUniqueEnumerableT(type, out var t))
				{
					t = null;
				}
				if ((object)t == null && type.IsArray && type.GetArrayRank() == 1 && type != typeof(byte[]))
				{
					t = type.GetElementType();
				}
				if ((object)t != null)
				{
					if (insideList)
					{
						ThrowNestedListsNotSupported((parentListOrType as Type) ?? parentListOrType?.GetType());
					}
					flag = TryDeserializeList(ref state, format, tag, type, t, ref value, isRoot);
					if (!flag && autoCreate)
					{
						value = CreateListInstance(type, t);
					}
					return flag;
				}
				ThrowUnexpectedType(type, this);
			}
			if (!DynamicStub.CanSerialize(type, this, out var features))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Unable to deserialize aux type: " + type.NormalizeName());
			}
			while (!(flag && asListItem))
			{
				int num = state.ReadFieldHeader();
				if (num <= 0)
				{
					break;
				}
				if (num != tag)
				{
					if (skipOtherFields)
					{
						state.SkipField();
						continue;
					}
					state.ThrowInvalidOperationException($"Expected field {tag}, but found {num}");
				}
				flag = true;
				state.Hint(wireType);
				ObjectScope scope = NormalizeAuxScope(features, insideList, type, isRoot);
				value = Deserialize(scope, ref state, type, value);
			}
			if (!flag && !asListItem && autoCreate && type != typeof(string))
			{
				value = Activator.CreateInstance(type, nonPublic: true);
			}
			return flag;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static TypeModel SetDefaultModel(TypeModel newValue)
		{
			if (newValue == null || newValue is NullModel)
			{
				Interlocked.CompareExchange(ref s_defaultModel, NullModel.Singleton, null);
			}
			else
			{
				Interlocked.Exchange(ref s_defaultModel, newValue);
			}
			return Volatile.Read(ref s_defaultModel);
		}

		internal static void ResetDefaultModel()
		{
			Volatile.Write(ref s_defaultModel, null);
		}

		[Obsolete("Use RuntimeTypeModel.Create", true)]
		public static TypeModel Create()
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			return null;
		}

		[Obsolete("Use RuntimeTypeModel.CreateForAssembly", true)]
		public static TypeModel CreateForAssembly<T>()
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			return null;
		}

		[Obsolete("Use RuntimeTypeModel.CreateForAssembly", true)]
		public static TypeModel CreateForAssembly(Type type)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			return null;
		}

		[Obsolete("Use RuntimeTypeModel.CreateForAssembly", true)]
		public static TypeModel CreateForAssembly(Assembly assembly)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			return null;
		}

		public bool IsDefined(Type type)
		{
			return IsDefined(type, CompatibilityLevel.NotSpecified);
		}

		internal bool IsDefined(Type type, CompatibilityLevel ambient)
		{
			if ((object)type != null)
			{
				return DynamicStub.IsKnownType(type, this, ambient);
			}
			return false;
		}

		protected virtual ISerializer<T> GetSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>()
		{
			return this as ISerializer<T>;
		}

		internal virtual ISerializer<T> GetSerializerCore<T>(CompatibilityLevel ambient)
		{
			return GetSerializer<T>();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static ISerializer<T> NoSerializer<T>(TypeModel model)
		{
			string text = null;
			if (model is NullModel)
			{
				text = "; you may need to ensure that RuntimeTypeModel.Initialize has been invoked";
			}
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("No serializer for type " + typeof(T).NormalizeName() + " is available for model " + (model?.ToString() ?? "(none)") + text);
			return null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static ISubTypeSerializer<T> NoSubTypeSerializer<T>(TypeModel model) where T : class
		{
			ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("No sub-type serializer for type " + typeof(T).NormalizeName() + " is available for model " + (model?.ToString() ?? "(none)"));
			return null;
		}

		internal static T CreateInstance<T>(ISerializationContext context, ISerializer<T> serializer = null)
		{
			if (TypeHelper<T>.IsReferenceType)
			{
				if (serializer == null)
				{
					serializer = TryGetSerializer<T>(context?.Model);
				}
				T val = default(T);
				if (serializer is IFactory<T> factory)
				{
					val = factory.Create(context);
				}
				if (val == null)
				{
					val = ActivatorCreate<T>();
				}
				return val;
			}
			return default(T);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static T ActivatorCreate<T>()
		{
			try
			{
				return (T)Activator.CreateInstance(typeof(T), nonPublic: true);
			}
			catch (MissingMethodException inner)
			{
				ThrowCannotCreateInstance(typeof(T), inner);
				return default(T);
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static ISerializer<T> GetSerializer<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(TypeModel model, CompatibilityLevel ambient = CompatibilityLevel.NotSpecified)
		{
			return SerializerCache<PrimaryTypeProvider, T>.InstanceField ?? model?.GetSerializerCore<T>(ambient) ?? NoSerializer<T>(model);
		}

		public static ISerializer<T> GetInbuiltSerializer<T>(CompatibilityLevel compatibilityLevel = CompatibilityLevel.NotSpecified, DataFormat dataFormat = DataFormat.Default)
		{
			if (compatibilityLevel >= CompatibilityLevel.Level300)
			{
				ISerializer<T> instanceField;
				if (dataFormat == DataFormat.FixedSize)
				{
					instanceField = SerializerCache<Level300FixedSerializer, T>.InstanceField;
					if (instanceField != null)
					{
						return instanceField;
					}
				}
				instanceField = SerializerCache<Level300DefaultSerializer, T>.InstanceField;
				if (instanceField != null)
				{
					return instanceField;
				}
			}
			else if (compatibilityLevel >= CompatibilityLevel.Level240 || dataFormat == DataFormat.WellKnown)
			{
				ISerializer<T> instanceField = SerializerCache<Level240DefaultSerializer, T>.InstanceField;
				if (instanceField != null)
				{
					return instanceField;
				}
			}
			return SerializerCache<PrimaryTypeProvider, T>.InstanceField;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static IRepeatedSerializer<T> GetRepeatedSerializer<T>(TypeModel model)
		{
			if (model?.GetSerializer<T>() is IRepeatedSerializer<T> result)
			{
				return result;
			}
			NoSerializer<T>(model);
			return null;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static ISerializer<T> TryGetSerializer<T>(TypeModel model)
		{
			ISerializer<T> serializer = SerializerCache<PrimaryTypeProvider, T>.InstanceField;
			if (serializer == null)
			{
				if (model == null)
				{
					return null;
				}
				serializer = model.GetSerializer<T>();
			}
			return serializer;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static ISubTypeSerializer<T> GetSubTypeSerializer<T>(TypeModel model) where T : class
		{
			return (model?.GetSerializer<T>() as ISubTypeSerializer<T>) ?? NoSubTypeSerializer<T>(model);
		}

		internal object Deserialize(ObjectScope scope, ref ProtoReader.State state, Type type, object value)
		{
			if (!DynamicStub.TryDeserialize(scope, type, this, ref state, ref value))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException(string.Format("{0} is not supported for {1} by {2}", "Deserialize", type.NormalizeName(), this));
			}
			return value;
		}

		public T DeepClone<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value, object userState = null)
		{
			if (TypeHelper<T>.CanBeNull && TypeHelper<T>.ValueChecker.IsNull(value))
			{
				return value;
			}
			ISerializer<T> serializer = TryGetSerializer<T>(this);
			if (serializer == null)
			{
				return (T)DeepCloneFallback(typeof(T), value);
			}
			if ((serializer.Features & SerializerFeatures.CategoryScalar) != 0)
			{
				return value;
			}
			using MemoryStream memoryStream = new MemoryStream();
			Serialize(memoryStream, value, userState);
			memoryStream.Position = 0L;
			return Deserialize(memoryStream, default(T), userState);
		}

		public object DeepClone(object value)
		{
			if (value == null)
			{
				return null;
			}
			Type type = value.GetType();
			if (!DynamicStub.TryDeepClone(type, this, ref value))
			{
				return DeepCloneFallback(type, value);
			}
			return value;
		}

		private object DeepCloneFallback(Type type, object value)
		{
			using MemoryStream memoryStream = new MemoryStream();
			ProtoWriter.State state = ProtoWriter.State.Create(memoryStream, this);
			PrepareDeserialize(value, ref type);
			try
			{
				if (!TrySerializeAuxiliaryType(ref state, type, DataFormat.Default, 1, value, isInsideList: false, null, isRoot: true))
				{
					ThrowUnexpectedType(type, this);
				}
				state.Close();
			}
			catch
			{
				state.Abandon();
				throw;
			}
			finally
			{
				state.Dispose();
			}
			memoryStream.Position = 0L;
			ProtoReader.State state2 = ProtoReader.State.Create(memoryStream, this, null, -1L);
			try
			{
				value = null;
				TryDeserializeAuxiliaryType(ref state2, DataFormat.Default, 1, type, ref value, skipOtherFields: true, asListItem: false, autoCreate: true, insideList: false, null, isRoot: true);
			}
			finally
			{
				state2.Dispose();
			}
			return value;
		}

		protected internal static void ThrowUnexpectedSubtype(Type expected, Type actual)
		{
			if (!DynamicStub.IsTypeEquivalent(expected, actual))
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Unexpected sub-type: " + actual.FullName);
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ThrowUnexpectedSubtype<[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] T>(T value) where T : class
		{
			if (IsSubType(value))
			{
				ThrowUnexpectedSubtype(typeof(T), value.GetType());
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ThrowUnexpectedSubtype<T, TConstruct>(T value) where T : class where TConstruct : class, T
		{
			if (IsSubType(value) && value.GetType() != typeof(TConstruct))
			{
				ThrowUnexpectedSubtype(typeof(T), value.GetType());
			}
		}

		public static bool IsSubType<T>(T value) where T : class
		{
			if (value != null)
			{
				return typeof(T) != value.GetType();
			}
			return false;
		}

		protected internal static void ThrowUnexpectedType(Type type, TypeModel model)
		{
			string text = (((object)type == null) ? "(unknown)" : type.FullName);
			if ((object)type != null)
			{
				Type baseType = type.BaseType;
				if ((object)baseType != null && baseType.IsGenericType && baseType.GetGenericTypeDefinition().Name == "GeneratedMessage`2")
				{
					ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Are you mixing protobuf-net and protobuf-csharp-port? See https://stackoverflow.com/q/11564914/23354; type: " + text);
				}
			}
			try
			{
				ProtoBuf.Internal.ThrowHelper.ThrowInvalidOperationException("Type is not expected, and no contract can be inferred: " + text);
			}
			catch (Exception ex) when (model != null)
			{
				ex.Data["TypeModel"] = model.ToString();
				throw;
			}
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowNestedListsNotSupported(Type type)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNestedDataNotSupported(type);
		}

		public static void ThrowCannotCreateInstance(Type type, Exception inner = null)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowProtoException("No parameterless constructor found for " + (type?.FullName ?? "(null)"), inner);
		}

		internal static string SerializeType(TypeModel model, Type type)
		{
			if (model != null)
			{
				TypeFormatEventHandler dynamicTypeFormatting = model.DynamicTypeFormatting;
				if (dynamicTypeFormatting != null)
				{
					TypeFormatEventArgs typeFormatEventArgs = new TypeFormatEventArgs(type);
					dynamicTypeFormatting(model, typeFormatEventArgs);
					if (!string.IsNullOrEmpty(typeFormatEventArgs.FormattedName))
					{
						return typeFormatEventArgs.FormattedName;
					}
				}
			}
			return type.AssemblyQualifiedName;
		}

		internal static Type DeserializeType(TypeModel model, string value)
		{
			if (model != null)
			{
				TypeFormatEventHandler dynamicTypeFormatting = model.DynamicTypeFormatting;
				if (dynamicTypeFormatting != null)
				{
					TypeFormatEventArgs typeFormatEventArgs = new TypeFormatEventArgs(value);
					dynamicTypeFormatting(model, typeFormatEventArgs);
					if ((object)typeFormatEventArgs.Type != null)
					{
						return typeFormatEventArgs.Type;
					}
				}
			}
			return Type.GetType(value);
		}

		public bool CanSerializeContractType(Type type)
		{
			SerializerFeatures category;
			return CanSerialize(type, allowBasic: false, allowContract: true, allowLists: true, out category);
		}

		public bool CanSerialize(Type type)
		{
			SerializerFeatures category;
			return CanSerialize(type, allowBasic: true, allowContract: true, allowLists: true, out category);
		}

		public bool CanSerializeBasicType(Type type)
		{
			SerializerFeatures category;
			return CanSerialize(type, allowBasic: true, allowContract: false, allowLists: true, out category);
		}

		internal bool CanSerialize(Type type, bool allowBasic, bool allowContract, bool allowLists, out SerializerFeatures category)
		{
			if ((object)type == null)
			{
				ProtoBuf.Internal.ThrowHelper.ThrowArgumentNullException("type");
			}
			do
			{
				if (!DynamicStub.CanSerialize(type, this, out var features))
				{
					continue;
				}
				category = features.GetCategory();
				switch (category)
				{
				case SerializerFeatures.CategoryRepeated:
					if (allowLists)
					{
						return DoCheckLists(type, this, allowBasic, allowContract);
					}
					return false;
				case SerializerFeatures.CategoryMessage:
					return allowContract;
				case SerializerFeatures.CategoryScalar:
				case SerializerFeatures.CategoryMessageWrappedAtRoot:
					return allowBasic;
				}
			}
			while (CheckIfNullableT(ref type));
			category = SerializerFeatures.CategoryRepeated;
			return false;
			static bool CheckIfNullableT(ref Type type)
			{
				Type underlyingType = Nullable.GetUnderlyingType(type);
				if ((object)underlyingType != null)
				{
					type = underlyingType;
					return true;
				}
				return false;
			}
			static bool DoCheckLists(Type type, TypeModel model, bool allowBasic, bool allowContract)
			{
				SerializerFeatures category2;
				if (TypeHelper.ResolveUniqueEnumerableT(type, out var t))
				{
					return model.CanSerialize(t, allowBasic, allowContract, allowLists: false, out category2);
				}
				return false;
			}
		}

		public string GetSchema([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type)
		{
			return GetSchema(type, ProtoSyntax.Default);
		}

		public string GetSchema([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type, ProtoSyntax syntax)
		{
			SchemaGenerationOptions schemaGenerationOptions;
			if ((object)type == null && syntax == ProtoSyntax.Default)
			{
				schemaGenerationOptions = SchemaGenerationOptions.Default;
			}
			else
			{
				schemaGenerationOptions = new SchemaGenerationOptions
				{
					Syntax = syntax
				};
				if ((object)type != null)
				{
					schemaGenerationOptions.Types.Add(type);
				}
			}
			return GetSchema(schemaGenerationOptions);
		}

		public virtual string GetSchema(SchemaGenerationOptions options)
		{
			ProtoBuf.Internal.ThrowHelper.ThrowNotSupportedException();
			return null;
		}

		public IFormatter CreateFormatter([DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties)] Type type)
		{
			return new Formatter(this, type);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static Type ResolveKnownType(string name, Assembly assembly)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			try
			{
				Type type = Type.GetType(name);
				if ((object)type != null)
				{
					return type;
				}
			}
			catch
			{
			}
			try
			{
				int num = name.IndexOf(',');
				string name2 = ((num > 0) ? name.Substring(0, num) : name).Trim();
				if ((object)assembly == null)
				{
					assembly = Assembly.GetCallingAssembly();
				}
				Type type2 = assembly?.GetType(name2);
				if ((object)type2 != null)
				{
					return type2;
				}
			}
			catch
			{
			}
			return null;
		}

		T IProtoInput<Stream>.Deserialize<T>(Stream source, T value, object userState)
		{
			return Deserialize(source, value, userState);
		}

		T IProtoInput<ArraySegment<byte>>.Deserialize<T>(ArraySegment<byte> source, T value, object userState)
		{
			return Deserialize(new ReadOnlyMemory<byte>(source.Array, source.Offset, source.Count), value, userState);
		}

		T IProtoInput<byte[]>.Deserialize<T>(byte[] source, T value, object userState)
		{
			return Deserialize(new ReadOnlyMemory<byte>(source), value, userState);
		}

		void IProtoOutput<Stream>.Serialize<T>(Stream destination, T value, object userState)
		{
			Serialize(destination, value, userState);
		}

		void IProtoOutput<IBufferWriter<byte>>.Serialize<T>(IBufferWriter<byte> destination, T value, object userState)
		{
			Serialize(destination, value, userState);
		}

		void IMeasuredProtoOutput<Stream>.Serialize<T>(MeasureState<T> measured, Stream destination)
		{
			measured.Serialize(destination);
		}

		void IMeasuredProtoOutput<IBufferWriter<byte>>.Serialize<T>(MeasureState<T> measured, IBufferWriter<byte> destination)
		{
			measured.Serialize(destination);
		}

		MeasureState<T> IMeasuredProtoOutput<Stream>.Measure<T>(T value, object userState)
		{
			return Measure(value, userState, -1L);
		}

		MeasureState<T> IMeasuredProtoOutput<IBufferWriter<byte>>.Measure<T>(T value, object userState)
		{
			return Measure(value, userState, -1L);
		}
	}
}
namespace ProtoBuf.Internal
{
	internal sealed class DynamicAccess
	{
		internal const DynamicallyAccessedMemberTypes ContractType = DynamicallyAccessedMemberTypes.PublicConstructors | DynamicallyAccessedMemberTypes.NonPublicConstructors | DynamicallyAccessedMemberTypes.PublicMethods | DynamicallyAccessedMemberTypes.NonPublicMethods | DynamicallyAccessedMemberTypes.PublicFields | DynamicallyAccessedMemberTypes.NonPublicFields | DynamicallyAccessedMemberTypes.PublicProperties | DynamicallyAccessedMemberTypes.NonPublicProperties;

		internal const DynamicallyAccessedMemberTypes Serializer = DynamicallyAccessedMemberTypes.PublicParameterlessConstructor | DynamicallyAccessedMemberTypes.PublicMethods;
	}
	internal enum ObjectScope
	{
		Invalid,
		NakedMessage,
		LikeRoot,
		WrappedMessage,
		Scalar
	}
	internal abstract class DynamicStub
	{
		private class NilStub : DynamicStub
		{
			public static readonly NilStub Instance = new NilStub();

			protected NilStub()
			{
			}

			protected override bool TryDeserializeRoot(TypeModel model, ref ProtoReader.State state, ref object value, bool autoCreate)
			{
				return false;
			}

			protected override bool TryDeserialize(ObjectScope scope, TypeModel model, ref ProtoReader.State state, ref object value)
			{
				return false;
			}

			protected override bool TrySerializeRoot(TypeModel model, ref ProtoWriter.State state, object value)
			{
				return false;
			}

			protected override bool TrySerializeAny(int fieldNumber, SerializerFeatures features, TypeModel model, ref ProtoWriter.State state, object value)
			{
				return false;
			}

			protected override bool TryDeepClone(TypeModel model, ref object value)
			{
				return false;
			}

			protected override bool IsKnownType(TypeModel model, CompatibilityLevel ambient)
			{
				return false;
			}

			protected override bool CanSerialize(TypeModel model, out SerializerFeatures features)
			{
				features = SerializerFeatures.CategoryRepeated;
				return false;
			}

			protected override Type GetEffectiveType()
			{
				return null;
			}
		}

		private sealed class ConcreteStub<T> : DynamicStub
		{
			protected override Type GetEffectiveType()
			{
				return typeof(T);
			}

			protected override bool TryDeserializeRoot(TypeModel model, ref ProtoReader.State state, ref object value, bool autoCreate)
			{
				ISerializer<T> serializer = TypeModel.TryGetSerializer<T>(model);
				if (serializer == null)
				{
					return false;
				}
				bool flag = !autoCreate && value == null;
				long position = state.GetPosition();
				value = state.DeserializeRoot(TypeHelper<T>.FromObject(value), serializer);
				if (flag && position == state.GetPosition())
				{
					value = null;
				}
				return true;
			}

			protected override bool TryDeserialize(ObjectScope scope, TypeModel model, ref ProtoReader.State state, ref object value)
			{
				ISerializer<T> serializer = TypeModel.TryGetSerializer<T>(model);
				if (serializer == null)
				{
					return false;
				}
				T value2 = TypeHelper<T>.FromObject(value);
				switch (scope)
				{
				case ObjectScope.LikeRoot:
					value2 = state.ReadAsRoot(value2, serializer);
					break;
				case ObjectScope.NakedMessage:
				case ObjectScope.Scalar:
					value2 = serializer.Read(ref state, value2);
					break;
				case ObjectScope.WrappedMessage:
					value2 = state.ReadMessage(SerializerFeatures.CategoryRepeated, value2, serializer);
					break;
				default:
					return false;
				}
				value = value2;
				return true;
			}

			protected override bool IsKnownType(TypeModel model, CompatibilityLevel ambient)
			{
				return model?.IsKnownType<T>(ambient) ?? false;
			}

			protected override bool CanSerialize(TypeModel model, out SerializerFeatures features)
			{
				ISerializer<T> serializer;
				try
				{
					serializer = TypeModel.TryGetSerializer<T>(model);
				}
				catch
				{
					features = SerializerFeatures.CategoryRepeated;
					return false;
				}
				if (serializer == null)
				{
					features = SerializerFeatures.CategoryRepeated;
					return false;
				}
				features = serializer.Features;
				return true;
			}

			protected override bool TrySerializeRoot(TypeModel model, ref ProtoWriter.State state, object value)
			{
				ISerializer<T> serializer = TypeModel.TryGetSerializer<T>(model);
				if (serializer == null)
				{
					return false;
				}
				state.SerializeRoot(TypeHelper<T>.FromObject(value), serializer);
				return true;
			}

			protected override bool TrySerializeAny(int fieldNumber, SerializerFeatures features, TypeModel model, ref ProtoWriter.State state, object value)
			{
				ISerializer<T> serializer = TypeModel.TryGetSerializer<T>(model);
				if (serializer == null)
				{
					return false;
				}
				T value2 = TypeHelper<T>.FromObject(value);
				CheckAnyAuxFlow(features, serializer);
				if ((features & SerializerFeatures.CategoryMessageWrappedAtRoot) == SerializerFeatures.CategoryMessageWrappedAtRoot)
				{
					if (fieldNumber != 1)
					{
						ThrowHelper.ThrowInvalidOperationException($"Special root-like wrapping is limited to field {1}");
					}
					state.WriteAsRoot(value2, serializer);
				}
				else
				{
					state.WriteAny(fieldNumber, features, value2, serializer);
				}
				return true;
			}

			private static void CheckAnyAuxFlow(SerializerFeatures features, ISerializer<T> serializer)
			{
				if ((features & (SerializerFeatures)1073741824) != 0 && serializer.Features.GetCategory() == SerializerFeatures.CategoryMessageWrappedAtRoot)
				{
					ThrowHelper.ThrowNotImplementedException("Tell Marc: ambiguous category in an any/aux flow for " + typeof(T).NormalizeName());
				}
			}

			protected override bool TryDeepClone(TypeModel model, ref object value)
			{
				if (TypeModel.TryGetSerializer<T>(model) == null)
				{
					return false;
				}
				value = model.DeepClone(TypeHelper<T>.FromObject(value));
				return true;
			}
		}

		private static readonly Hashtable s_byType = new Hashtable { 
		{
			typeof(object),
			NilStub.Instance
		} };

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryDeserializeRoot(Type type, TypeModel model, ref ProtoReader.State state, ref object value, bool autoCreate)
		{
			return Get(type).TryDeserializeRoot(model, ref state, ref value, autoCreate);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TrySerializeRoot(Type type, TypeModel model, ref ProtoWriter.State state, object value)
		{
			do
			{
				if (Get(type).TrySerializeRoot(model, ref state, value))
				{
					return true;
				}
				type = type.BaseType;
			}
			while ((object)type != null && type != typeof(object));
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryDeserialize(ObjectScope scope, Type type, TypeModel model, ref ProtoReader.State state, ref object value)
		{
			return Get(type).TryDeserialize(scope, model, ref state, ref value);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TrySerializeAny(int fieldNumber, SerializerFeatures features, Type type, TypeModel model, ref ProtoWriter.State state, object value)
		{
			do
			{
				if (Get(type).TrySerializeAny(fieldNumber, features, model, ref state, value))
				{
					return true;
				}
				type = type.BaseType;
			}
			while ((object)type != null && type != typeof(object));
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool TryDeepClone(Type type, TypeModel model, ref object value)
		{
			do
			{
				if (Get(type).TryDeepClone(model, ref value))
				{
					return true;
				}
				type = type.BaseType;
			}
			while ((object)type != null && type != typeof(object));
			return false;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		internal static bool IsKnownType(Type type, TypeModel model, CompatibilityLevel ambient)
		{
			return Get(type).IsKnownType(model, ambient);
		}

		internal static bool CanSerialize(Type type, TypeModel model, out SerializerFeatures features)
		{
			return Get(type).CanSerialize(model, out features);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		private static DynamicStub Get(Type type)
		{
			return ((DynamicStub)s_byType[type]) ?? SlowGet(type);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private static DynamicStub SlowGet(Type type)
		{
			if ((object)type == null)
			{
				return NilStub.Instance;
			}
			DynamicStub dynamicStub = null;
			Type type2 = null;
			if (!type.IsGenericParameter)
			{
				type2 = ((!type.IsValueType) ? ResolveProxies(type) : Nullable.GetUnderlyingType(type));
			}
			else
			{
				dynamicStub = NilStub.Instance;
			}
			if (dynamicStub == null)
			{
				if ((object)type2 != null && type2 != type)
				{
					dynamicStub = Get(type2);
				}
				if (dynamicStub == null)
				{
					dynamicStub = TryCreateConcrete(typeof(ConcreteStub<>), new Type[1] { type });
				}
			}
			lock (s_byType)
			{
				s_byType[type] = dynamicStub;
				return dynamicStub;
			}
			static Type ResolveProxies(Type type)
			{
				if ((object)type == null)
				{
					return null;
				}
				if (type.IsGenericParameter)
				{
					return null;
				}
				string fullName = type.FullName;
				if (fullName != null && fullName.StartsWith("System.Data.Entity.DynamicProxies."))
				{
					return type.BaseType;
				}
				Type[] interfaces = type.GetInterfaces();
				Type[] array = interfaces;
				foreach (Type type3 in array)
				{
					switch (type3.FullName)
					{
					case "NHibernate.Proxy.INHibernateProxy":
					case "NHibernate.Proxy.DynamicProxy.IProxy":
					case "NHibernate.Intercept.IFieldInterceptorAccessor":
						return type.BaseType;
					}
				}
				return null;
			}
			static DynamicStub TryCreateConcrete(Type typeDef, Type[] args)
			{
				try
				{
					return (DynamicStub)Activator.CreateInstance(typeDef.MakeGenericType(args), nonPublic: true);
				}
				catch
				{
					return NilStub.Instance;
				}
			}
		}

		protected abstract bool TryDeserializeRoot(TypeModel model, ref ProtoReader.State state, ref object value, bool autoCreate);

		protected abstract bool TryDeserialize(ObjectScope scope, TypeModel model, ref ProtoReader.State state, ref object value);

		protected abstract bool TrySerializeRoot(TypeModel model, ref ProtoWriter.State state, object value);

		protected abstract bool TrySerializeAny(int fieldNumber, SerializerFeatures features, TypeModel model, ref ProtoWriter.State state, object value);

		protected abstract bool TryDeepClone(TypeModel model, ref object value);

		protected abstract bool IsKnownType(TypeModel model, CompatibilityLevel ambient);

		protected abstract bool CanSerialize(TypeModel model, out SerializerFeatures features);

		internal static bool IsTypeEquivalent(Type expected, Type actual)
		{
			if ((object)expected != actual)
			{
				return Get(expected) == Get(actual);
			}
			return true;
		}

		internal static Type GetEffectiveType(Type type)
		{
			object obj;
			if ((object)type != null)
			{
				obj = Get(type).GetEffectiveType();
				if (obj == null)
				{
					return type;
				}
			}
			else
			{
				obj = null;
			}
			return (Type)obj;
		}

		protected abstract Type GetEffectiveType();
	}
	internal sealed class FixedMemoryManager : MemoryManager<byte>
	{
		private unsafe byte* _pointer;

		private int _length;

		internal unsafe Memory<byte> Init(byte* pointer, int length)
		{
			_pointer = pointer;
			_length = length;
			return Memory;
		}

		public unsafe override Span<byte> GetSpan()
		{
			return new Span<byte>(_pointer, _length);
		}

		public override MemoryHandle Pin(int elementIndex = 0)
		{
			throw new NotSupportedException();
		}

		public override void Unpin()
		{
			throw new NotSupportedException();
		}

		protected override void Dispose(bool disposing)
		{
		}
	}
	internal static class GuidHelper
	{
		internal const int WRITE_BYTES_LENGTH = 16;

		internal const int WRITE_STRING_LENGTH = 36;

		internal const int MAX_LENGTH = 40;

		internal unsafe static Guid Read(ref ProtoReader.State state)
		{
			byte* ptr = stackalloc byte[40];
			Span<byte> span = state.ReadBytes(new Span<byte>(ptr, 40));
			char standardFormat;
			switch (span.Length)
			{
			case 0:
				return Guid.Empty;
			case 16:
			{
				int num = 32;
				for (int num2 = 15; num2 >= 0; num2--)
				{
					byte b = ptr[num2];
					ptr[--num] = ToHex(b & 0xF);
					ptr[--num] = ToHex((b >> 4) & 0xF);
				}
				span = new Span<byte>(ptr, 32);
				standardFormat = 'N';
				break;
			}
			case 32:
				standardFormat = 'N';
				break;
			case 36:
				standardFormat = 'D';
				break;
			default:
				ThrowHelper.Format($"Unexpected Guid length: {span.Length}");
				return default(Guid);
			}
			if (!Utf8Parser.TryParse((ReadOnlySpan<byte>)span, out Guid value2, out int bytesConsumed, standardFormat) || bytesConsumed != span.Length)
			{
				ThrowHelper.Format("Failed to read Guid: '" + Encoding.UTF8.GetString(ptr, span.Length) + "'");
			}
			return value2;
			static byte ToHex(int value)
			{
				return (byte)"0123456789abcdef"[value];
			}
		}

		internal static void Write(ref ProtoWriter.State state, in Guid value, bool asBytes)
		{
			Guid guid = value;
			if (guid.Equals(Guid.Empty))
			{
				state.WriteBytes(default(ReadOnlyMemory<byte>));
				return;
			}
			byte[] array = ArrayPool<byte>.Shared.Rent(40);
			try
			{
				if (!Utf8Formatter.TryFormat(value, array, out var bytesWritten, asBytes ? 'N' : 'D'))
				{
					ThrowHelper.Format($"Failed to write Guid: '{value}'");
				}
				if (asBytes)
				{
					int num = 0;
					for (int i = 0; i < 16; i++)
					{
						array[i] = (byte)((FromHex(array[num++]) << 4) | FromHex(array[num++]));
					}
					bytesWritten = 16;
				}
				state.WriteBytes(new ReadOnlyMemory<byte>(array, 0, bytesWritten));
			}
			finally
			{
				ArrayPool<byte>.Shared.Return(array);
			}
			static int FromHex(int value)
			{
				if (value >= 48 && value <= 57)
				{
					return value - 48;
				}
				if (value >= 97 && value <= 102)
				{
					return 10 + value - 97;
				}
				if (value >= 65 && value <= 70)
				{
					return 10 + value - 65;
				}
				Throw(value);
				return 0;
			}
			static void Throw(int value)
			{
				ThrowHelper.ThrowArgumentOutOfRangeException("value", $"Unexpected hex character: '{(char)value}'");
			}
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal readonly struct KeyValuePairSerializer<TKey, TValue> : ISerializer<KeyValuePair<TKey, TValue>>
	{
		private readonly ISerializer<TKey> _keySerializer;

		private readonly ISerializer<TValue> _valueSerializer;

		private readonly SerializerFeatures _keyFeatures;

		private readonly SerializerFeatures _valueFeatures;

		public SerializerFeatures Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		internal KeyValuePairSerializer(ISerializer<TKey> keySerializer, SerializerFeatures keyFeatures, ISerializer<TValue> valueSerializer, SerializerFeatures valueFeatures)
		{
			_keySerializer = keySerializer;
			_valueSerializer = valueSerializer;
			_keyFeatures = keyFeatures;
			_valueFeatures = valueFeatures;
		}

		public KeyValuePair<TKey, TValue> Read(ref ProtoReader.State state, KeyValuePair<TKey, TValue> pair)
		{
			TKey val = pair.Key;
			TValue value = pair.Value;
			int num;
			while ((num = state.ReadFieldHeader()) > 0)
			{
				switch (num)
				{
				case 1:
					val = state.ReadAny(_keyFeatures, val, _keySerializer);
					break;
				case 2:
					value = state.ReadAny(_valueFeatures, value, _valueSerializer);
					break;
				default:
					state.SkipField();
					break;
				}
			}
			if (TypeHelper<TKey>.IsReferenceType && TypeHelper<TKey>.ValueChecker.IsNull(val))
			{
				val = CreateDefault(state.Context, _keySerializer, _keyFeatures);
			}
			if (TypeHelper<TValue>.IsReferenceType && TypeHelper<TValue>.ValueChecker.IsNull(value))
			{
				value = CreateDefault(state.Context, _valueSerializer, _valueFeatures);
			}
			return new KeyValuePair<TKey, TValue>(val, value);
		}

		private static T CreateDefault<T>(ISerializationContext context, ISerializer<T> serializer, SerializerFeatures features)
		{
			if (features.HasAny(SerializerFeatures.OptionWrappedValue))
			{
				return default(T);
			}
			if (serializer != null && serializer.Features.GetCategory() == SerializerFeatures.CategoryMessage)
			{
				ProtoReader.State state = ProtoReader.State.Create(default(ReadOnlyMemory<byte>), context?.Model, context?.UserState);
				try
				{
					return serializer.Read(ref state, default(T));
				}
				finally
				{
					state.Dispose();
				}
			}
			return TypeModel.CreateInstance(context, serializer);
		}

		public void Write(ref ProtoWriter.State state, KeyValuePair<TKey, TValue> value)
		{
			if (TypeHelper<TKey>.ValueChecker.HasNonTrivialValue(value.Key))
			{
				state.WriteAny(1, _keyFeatures, value.Key, _keySerializer);
			}
			if (TypeHelper<TValue>.ValueChecker.HasNonTrivialValue(value.Value))
			{
				state.WriteAny(2, _valueFeatures, value.Value, _valueSerializer);
			}
		}
	}
	internal class Level240DefaultSerializer : ISerializer<DateTime>, ISerializer<DateTime?>, ISerializer<TimeSpan>, ISerializer<TimeSpan?>
	{
		SerializerFeatures ISerializer<TimeSpan>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<TimeSpan?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<DateTime>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<DateTime?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		DateTime? ISerializer<DateTime?>.Read(ref ProtoReader.State state, DateTime? value)
		{
			return ((ISerializer<DateTime>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<DateTime?>.Write(ref ProtoWriter.State state, DateTime? value)
		{
			((ISerializer<DateTime>)this).Write(ref state, value.Value);
		}

		TimeSpan? ISerializer<TimeSpan?>.Read(ref ProtoReader.State state, TimeSpan? value)
		{
			return ((ISerializer<TimeSpan>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<TimeSpan?>.Write(ref ProtoWriter.State state, TimeSpan? value)
		{
			((ISerializer<TimeSpan>)this).Write(ref state, value.Value);
		}

		DateTime ISerializer<DateTime>.Read(ref ProtoReader.State state, DateTime value)
		{
			return PrimaryTypeProvider.ReadTimestamp(ref state, value);
		}

		void ISerializer<DateTime>.Write(ref ProtoWriter.State state, DateTime value)
		{
			PrimaryTypeProvider.WriteTimestamp(ref state, value);
		}

		TimeSpan ISerializer<TimeSpan>.Read(ref ProtoReader.State state, TimeSpan value)
		{
			return PrimaryTypeProvider.ReadDuration(ref state, value);
		}

		void ISerializer<TimeSpan>.Write(ref ProtoWriter.State state, TimeSpan value)
		{
			PrimaryTypeProvider.WriteDuration(ref state, value);
		}
	}
	internal class Level300DefaultSerializer : Level240DefaultSerializer, ISerializer<decimal>, ISerializer<decimal?>, IValueChecker<decimal>, ISerializer<Guid>, ISerializer<Guid?>, IValueChecker<Guid>
	{
		SerializerFeatures ISerializer<Guid>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<Guid?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<decimal>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<decimal?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		bool IValueChecker<decimal>.HasNonTrivialValue(decimal value)
		{
			return !value.Equals(0m);
		}

		bool IValueChecker<decimal>.IsNull(decimal value)
		{
			return false;
		}

		bool IValueChecker<Guid>.HasNonTrivialValue(Guid value)
		{
			return !value.Equals(Guid.Empty);
		}

		bool IValueChecker<Guid>.IsNull(Guid value)
		{
			return false;
		}

		Guid ISerializer<Guid>.Read(ref ProtoReader.State state, Guid value)
		{
			return GuidHelper.Read(ref state);
		}

		void ISerializer<Guid>.Write(ref ProtoWriter.State state, Guid value)
		{
			GuidHelper.Write(ref state, in value, asBytes: false);
		}

		decimal ISerializer<decimal>.Read(ref ProtoReader.State state, decimal value)
		{
			return BclHelpers.ReadDecimalString(ref state);
		}

		void ISerializer<decimal>.Write(ref ProtoWriter.State state, decimal value)
		{
			BclHelpers.WriteDecimalString(ref state, value);
		}

		decimal? ISerializer<decimal?>.Read(ref ProtoReader.State state, decimal? value)
		{
			return ((ISerializer<decimal>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<decimal?>.Write(ref ProtoWriter.State state, decimal? value)
		{
			((ISerializer<decimal>)this).Write(ref state, value.Value);
		}

		Guid? ISerializer<Guid?>.Read(ref ProtoReader.State state, Guid? value)
		{
			return ((ISerializer<Guid>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<Guid?>.Write(ref ProtoWriter.State state, Guid? value)
		{
			((ISerializer<Guid>)this).Write(ref state, value.Value);
		}
	}
	internal sealed class Level300FixedSerializer : ISerializer<Guid>, ISerializer<Guid?>, IValueChecker<Guid>
	{
		SerializerFeatures ISerializer<Guid>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<Guid?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		Guid ISerializer<Guid>.Read(ref ProtoReader.State state, Guid value)
		{
			return GuidHelper.Read(ref state);
		}

		void ISerializer<Guid>.Write(ref ProtoWriter.State state, Guid value)
		{
			GuidHelper.Write(ref state, in value, asBytes: true);
		}

		Guid? ISerializer<Guid?>.Read(ref ProtoReader.State state, Guid? value)
		{
			return ((ISerializer<Guid>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<Guid?>.Write(ref ProtoWriter.State state, Guid? value)
		{
			((ISerializer<Guid>)this).Write(ref state, value.Value);
		}

		bool IValueChecker<Guid>.HasNonTrivialValue(Guid value)
		{
			return !value.Equals(Guid.Empty);
		}

		bool IValueChecker<Guid>.IsNull(Guid value)
		{
			return false;
		}
	}
	internal static class Pool<T> where T : class
	{
		[ThreadStatic]
		private static T ts_local;

		private const int POOL_SIZE = 20;

		private static readonly Queue<T> s_pool = new Queue<T>(20);

		internal static T TryGet()
		{
			T val = ts_local;
			if (val != null)
			{
				ts_local = null;
				return val;
			}
			return GetShared();
		}

		internal static void Put(T obj)
		{
			if (obj != null)
			{
				if (ts_local == null)
				{
					ts_local = obj;
				}
				else
				{
					PutShared(obj);
				}
			}
		}

		private static T GetShared()
		{
			Queue<T> queue = s_pool;
			lock (queue)
			{
				return (queue.Count == 0) ? null : queue.Dequeue();
			}
		}

		private static void PutShared(T obj)
		{
			Queue<T> queue = s_pool;
			lock (queue)
			{
				if (queue.Count < 20)
				{
					queue.Enqueue(obj);
				}
			}
		}
	}
	internal class PrimaryTypeProvider : ISerializer<decimal>, ISerializer<decimal?>, ISerializer<Guid>, ISerializer<Guid?>, IMeasuringSerializer<string>, ISerializer<string>, IMeasuringSerializer<int>, ISerializer<int>, IMeasuringSerializer<long>, ISerializer<long>, IMeasuringSerializer<bool>, ISerializer<bool>, IMeasuringSerializer<float>, ISerializer<float>, IMeasuringSerializer<double>, ISerializer<double>, IMeasuringSerializer<byte[]>, ISerializer<byte[]>, IMeasuringSerializer<ArraySegment<byte>>, ISerializer<ArraySegment<byte>>, IMeasuringSerializer<Memory<byte>>, ISerializer<Memory<byte>>, IMeasuringSerializer<ReadOnlyMemory<byte>>, ISerializer<ReadOnlyMemory<byte>>, IMeasuringSerializer<byte>, ISerializer<byte>, IMeasuringSerializer<ushort>, ISerializer<ushort>, IMeasuringSerializer<uint>, ISerializer<uint>, IMeasuringSerializer<ulong>, ISerializer<ulong>, IMeasuringSerializer<sbyte>, ISerializer<sbyte>, IMeasuringSerializer<short>, ISerializer<short>, IMeasuringSerializer<char>, ISerializer<char>, IMeasuringSerializer<Uri>, ISerializer<Uri>, IMeasuringSerializer<Type>, ISerializer<Type>, IMeasuringSerializer<IntPtr>, ISerializer<IntPtr>, IMeasuringSerializer<UIntPtr>, ISerializer<UIntPtr>, IFactory<string>, IFactory<byte[]>, IMeasuringSerializer<int?>, ISerializer<int?>, IMeasuringSerializer<long?>, ISerializer<long?>, IMeasuringSerializer<bool?>, ISerializer<bool?>, IMeasuringSerializer<float?>, ISerializer<float?>, IMeasuringSerializer<double?>, ISerializer<double?>, IMeasuringSerializer<byte?>, ISerializer<byte?>, IMeasuringSerializer<ushort?>, ISerializer<ushort?>, IMeasuringSerializer<uint?>, ISerializer<uint?>, IMeasuringSerializer<ulong?>, ISerializer<ulong?>, IMeasuringSerializer<sbyte?>, ISerializer<sbyte?>, IMeasuringSerializer<short?>, ISerializer<short?>, IMeasuringSerializer<char?>, ISerializer<char?>, IMeasuringSerializer<IntPtr?>, ISerializer<IntPtr?>, IMeasuringSerializer<UIntPtr?>, ISerializer<UIntPtr?>, IValueChecker<string>, IValueChecker<int>, IValueChecker<long>, IValueChecker<bool>, IValueChecker<float>, IValueChecker<double>, IValueChecker<byte[]>, IValueChecker<byte>, IValueChecker<ushort>, IValueChecker<uint>, IValueChecker<ulong>, IValueChecker<sbyte>, IValueChecker<short>, IValueChecker<char>, IValueChecker<IntPtr>, IValueChecker<UIntPtr>, IValueChecker<Uri>, IValueChecker<Type>, IValueChecker<int?>, IValueChecker<long?>, IValueChecker<bool?>, IValueChecker<float?>, IValueChecker<double?>, IValueChecker<byte?>, IValueChecker<ushort?>, IValueChecker<uint?>, IValueChecker<ulong?>, IValueChecker<sbyte?>, IValueChecker<short?>, IValueChecker<char?>, IValueChecker<IntPtr?>, IValueChecker<UIntPtr?>, ISerializer<PrimaryTypeProvider.ScaledTicks>, ISerializer<TimeSpan>, ISerializer<TimeSpan?>, ISerializer<DateTime>, ISerializer<DateTime?>, ISerializer<Duration>, ISerializer<Duration?>, ISerializer<Empty>, ISerializer<Empty?>, ISerializer<Timestamp>, ISerializer<Timestamp?>
	{
		[StructLayout(LayoutKind.Explicit)]
		private readonly struct DecimalAccessor
		{
			[FieldOffset(0)]
			public readonly int Flags;

			[FieldOffset(4)]
			public readonly int Hi;

			[FieldOffset(8)]
			public readonly int Lo;

			[FieldOffset(12)]
			public readonly int Mid;

			[FieldOffset(0)]
			public readonly decimal Decimal;

			public DecimalAccessor(decimal value)
			{
				this = default(DecimalAccessor);
				Decimal = value;
			}
		}

		[StructLayout(LayoutKind.Explicit)]
		private readonly struct GuidAccessor
		{
			[FieldOffset(0)]
			public readonly Guid Guid;

			[FieldOffset(0)]
			public readonly ulong Low;

			[FieldOffset(8)]
			public readonly ulong High;

			public GuidAccessor(Guid value)
			{
				Low = (High = 0uL);
				Guid = value;
			}

			public GuidAccessor(ulong low, ulong high)
			{
				Guid = default(Guid);
				Low = low;
				High = high;
			}
		}

		[StructLayout(LayoutKind.Auto)]
		[ProtoContract(Name = ".bcl.TimeSpan")]
		internal readonly struct ScaledTicks
		{
			internal const int FieldTimeSpanValue = 1;

			internal const int FieldTimeSpanScale = 2;

			internal const int FieldTimeSpanKind = 3;

			[ProtoMember(1, DataFormat = DataFormat.ZigZag, Name = "value")]
			public long Value { get; }

			[ProtoMember(2, Name = "scale")]
			public TimeSpanScale Scale { get; }

			[ProtoMember(3, Name = "kind")]
			public DateTimeKind Kind { get; }

			public ScaledTicks(long value, TimeSpanScale scale, DateTimeKind kind)
			{
				Value = value;
				Scale = scale;
				Kind = kind;
			}

			public static ScaledTicks Create(DateTime value, bool includeKind)
			{
				if (value == DateTime.MinValue)
				{
					return new ScaledTicks(-1L, TimeSpanScale.MinMax, DateTimeKind.Unspecified);
				}
				if (value == DateTime.MaxValue)
				{
					return new ScaledTicks(1L, TimeSpanScale.MinMax, DateTimeKind.Unspecified);
				}
				DateTimeKind dateTimeKind = (includeKind ? value.Kind : DateTimeKind.Unspecified);
				return new ScaledTicks(value - BclHelpers.EpochOrigin[(int)dateTimeKind], dateTimeKind);
			}

			public DateTime ToDateTime()
			{
				long value;
				switch (Scale)
				{
				case TimeSpanScale.Days:
					value = Value * 864000000000L;
					break;
				case TimeSpanScale.Hours:
					value = Value * 36000000000L;
					break;
				case TimeSpanScale.Minutes:
					value = Value * 600000000;
					break;
				case TimeSpanScale.Seconds:
					value = Value * 10000000;
					break;
				case TimeSpanScale.Milliseconds:
					value = Value * 10000;
					break;
				case TimeSpanScale.Ticks:
					value = Value;
					break;
				case TimeSpanScale.MinMax:
					switch (Value)
					{
					case 1L:
						return DateTime.MaxValue;
					case -1L:
						return DateTime.MinValue;
					default:
						ThrowHelper.ThrowProtoException("Unknown min/max value: " + Value);
						return default(DateTime);
					}
				default:
					ThrowHelper.ThrowProtoException("Unknown timescale: " + Scale);
					return default(DateTime);
				}
				return BclHelpers.EpochOrigin[(int)Kind].AddTicks(value);
			}

			internal ScaledTicks(TimeSpan timeSpan, DateTimeKind kind)
			{
				long num = timeSpan.Ticks;
				TimeSpanScale timeSpanScale;
				if (timeSpan == TimeSpan.MaxValue)
				{
					num = 1L;
					timeSpanScale = TimeSpanScale.MinMax;
				}
				else if (timeSpan == TimeSpan.MinValue)
				{
					num = -1L;
					timeSpanScale = TimeSpanScale.MinMax;
				}
				else if (num % 864000000000L == 0L)
				{
					timeSpanScale = TimeSpanScale.Days;
					num /= 864000000000L;
				}
				else if (num % 36000000000L == 0L)
				{
					timeSpanScale = TimeSpanScale.Hours;
					num /= 36000000000L;
				}
				else if (num % 600000000 == 0L)
				{
					timeSpanScale = TimeSpanScale.Minutes;
					num /= 600000000;
				}
				else if (num % 10000000 == 0L)
				{
					timeSpanScale = TimeSpanScale.Seconds;
					num /= 10000000;
				}
				else if (num % 10000 == 0L)
				{
					timeSpanScale = TimeSpanScale.Milliseconds;
					num /= 10000;
				}
				else
				{
					timeSpanScale = TimeSpanScale.Ticks;
				}
				Kind = kind;
				Value = num;
				Scale = timeSpanScale;
			}

			public TimeSpan ToTimeSpan()
			{
				switch (Scale)
				{
				case TimeSpanScale.Days:
					return TimeSpan.FromDays(Value);
				case TimeSpanScale.Hours:
					return TimeSpan.FromHours(Value);
				case TimeSpanScale.Minutes:
					return TimeSpan.FromMinutes(Value);
				case TimeSpanScale.Seconds:
					return TimeSpan.FromSeconds(Value);
				case TimeSpanScale.Milliseconds:
					return TimeSpan.FromMilliseconds(Value);
				case TimeSpanScale.Ticks:
					return TimeSpan.FromTicks(Value);
				case TimeSpanScale.MinMax:
					switch (Value)
					{
					case 1L:
						return TimeSpan.MaxValue;
					case -1L:
						return TimeSpan.MinValue;
					default:
						ThrowHelper.ThrowProtoException("Unknown min/max value: " + Value);
						return default(TimeSpan);
					}
				default:
					ThrowHelper.ThrowProtoException("Unknown timescale: " + Scale);
					return default(TimeSpan);
				}
			}
		}

		private const int FieldDecimalLow = 1;

		private const int FieldDecimalHigh = 2;

		private const int FieldDecimalSignScale = 3;

		private static readonly bool s_decimalOptimized = VerifyDecimalLayout();

		private static readonly bool s_guidOptimized = VerifyGuidLayout();

		private const int FieldGuidLow = 1;

		private const int FieldGuidHigh = 2;

		SerializerFeatures ISerializer<decimal>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		SerializerFeatures ISerializer<decimal?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		internal static bool DecimalOptimized => s_decimalOptimized;

		SerializerFeatures ISerializer<Guid>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		SerializerFeatures ISerializer<Guid?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		internal static bool GuidOptimized => s_guidOptimized;

		SerializerFeatures ISerializer<string>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<int>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<byte[]>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<ArraySegment<byte>>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<Memory<byte>>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<ReadOnlyMemory<byte>>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<byte>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<ushort>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<uint>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<ulong>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<long>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<bool>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<float>.Features => SerializerFeatures.WireTypeFixed32 | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<double>.Features => SerializerFeatures.WireTypeFixed64 | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<sbyte>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<short>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<Uri>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<char>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<int?>.Features => ((ISerializer<int>)this).Features;

		SerializerFeatures ISerializer<short?>.Features => ((ISerializer<short>)this).Features;

		SerializerFeatures ISerializer<long?>.Features => ((ISerializer<long>)this).Features;

		SerializerFeatures ISerializer<sbyte?>.Features => ((ISerializer<sbyte>)this).Features;

		SerializerFeatures ISerializer<uint?>.Features => ((ISerializer<uint>)this).Features;

		SerializerFeatures ISerializer<ushort?>.Features => ((ISerializer<ushort>)this).Features;

		SerializerFeatures ISerializer<ulong?>.Features => ((ISerializer<ulong>)this).Features;

		SerializerFeatures ISerializer<byte?>.Features => ((ISerializer<byte>)this).Features;

		SerializerFeatures ISerializer<char?>.Features => ((ISerializer<char>)this).Features;

		SerializerFeatures ISerializer<bool?>.Features => ((ISerializer<bool>)this).Features;

		SerializerFeatures ISerializer<float?>.Features => ((ISerializer<float>)this).Features;

		SerializerFeatures ISerializer<double?>.Features => ((ISerializer<double>)this).Features;

		SerializerFeatures ISerializer<Type>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<IntPtr>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<UIntPtr>.Features => SerializerFeatures.WireTypeVarint | SerializerFeatures.CategoryScalar;

		SerializerFeatures ISerializer<IntPtr?>.Features => ((ISerializer<IntPtr>)this).Features;

		SerializerFeatures ISerializer<UIntPtr?>.Features => ((ISerializer<UIntPtr>)this).Features;

		SerializerFeatures ISerializer<DateTime>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		SerializerFeatures ISerializer<DateTime?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		SerializerFeatures ISerializer<TimeSpan>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		SerializerFeatures ISerializer<TimeSpan?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessageWrappedAtRoot;

		SerializerFeatures ISerializer<ScaledTicks>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<Duration>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<Duration?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<Empty>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<Empty?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<Timestamp>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		SerializerFeatures ISerializer<Timestamp?>.Features => SerializerFeatures.WireTypeString | SerializerFeatures.CategoryMessage;

		decimal? ISerializer<decimal?>.Read(ref ProtoReader.State state, decimal? value)
		{
			return ((ISerializer<decimal>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<decimal?>.Write(ref ProtoWriter.State state, decimal? value)
		{
			((ISerializer<decimal>)this).Write(ref state, value.Value);
		}

		decimal ISerializer<decimal>.Read(ref ProtoReader.State state, decimal value)
		{
			ulong num = 0uL;
			uint num2 = 0u;
			uint num3 = 0u;
			int num4;
			while ((num4 = state.ReadFieldHeader()) > 0)
			{
				switch (num4)
				{
				case 1:
					num = state.ReadUInt64();
					break;
				case 2:
					num2 = state.ReadUInt32();
					break;
				case 3:
					num3 = state.ReadUInt32();
					break;
				default:
					state.SkipField();
					break;
				}
			}
			int lo = (int)(num & 0xFFFFFFFFu);
			int mid = (int)((num >> 32) & 0xFFFFFFFFu);
			int hi = (int)num2;
			bool isNegative = (num3 & 1) == 1;
			byte scale = (byte)((num3 & 0x1FE) >> 1);
			return new decimal(lo, mid, hi, isNegative, scale);
		}

		void ISerializer<decimal>.Write(ref ProtoWriter.State state, decimal value)
		{
			ulong num3;
			uint num4;
			uint num5;
			if (s_decimalOptimized)
			{
				DecimalAccessor decimalAccessor = new DecimalAccessor(value);
				ulong num = (ulong)((long)decimalAccessor.Mid << 32);
				ulong num2 = (ulong)(decimalAccessor.Lo & 0xFFFFFFFFu);
				num3 = num | num2;
				num4 = (uint)decimalAccessor.Hi;
				num5 = ((uint)(decimalAccessor.Flags >> 15) & 0x1FEu) | ((uint)(decimalAccessor.Flags >> 31) & 1u);
			}
			else
			{
				int[] bits = decimal.GetBits(value);
				ulong num6 = (ulong)((long)bits[1] << 32);
				ulong num7 = (ulong)(bits[0] & 0xFFFFFFFFu);
				num3 = num6 | num7;
				num4 = (uint)bits[2];
				num5 = ((uint)(bits[3] >> 15) & 0x1FEu) | ((uint)(bits[3] >> 31) & 1u);
			}
			if (num3 != 0L)
			{
				state.WriteFieldHeader(1, WireType.Variant);
				state.WriteUInt64(num3);
			}
			if (num4 != 0)
			{
				state.WriteFieldHeader(2, WireType.Variant);
				state.WriteUInt32(num4);
			}
			if (num5 != 0)
			{
				state.WriteFieldHeader(3, WireType.Variant);
				state.WriteUInt32(num5);
			}
		}

		private static bool VerifyDecimalLayout()
		{
			try
			{
				decimal num = 1.0000000000000000000000000000m;
				DecimalAccessor decimalAccessor = new DecimalAccessor(num);
				if ((decimalAccessor.Lo == 268435456) & (decimalAccessor.Mid == 1042612833) & (decimalAccessor.Hi == 542101086) & (decimalAccessor.Flags == 1835008))
				{
					int[] bits = decimal.GetBits(num);
					if (bits.Length == 4)
					{
						return (decimalAccessor.Lo == bits[0]) & (decimalAccessor.Mid == bits[1]) & (decimalAccessor.Hi == bits[2]) & (decimalAccessor.Flags == bits[3]);
					}
				}
			}
			catch
			{
			}
			return false;
		}

		Guid? ISerializer<Guid?>.Read(ref ProtoReader.State state, Guid? value)
		{
			return ((ISerializer<Guid>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<Guid?>.Write(ref ProtoWriter.State state, Guid? value)
		{
			((ISerializer<Guid>)this).Write(ref state, value.Value);
		}

		Guid ISerializer<Guid>.Read(ref ProtoReader.State state, Guid value)
		{
			ulong num = 0uL;
			ulong num2 = 0uL;
			int num3;
			while ((num3 = state.ReadFieldHeader()) > 0)
			{
				switch (num3)
				{
				case 1:
					num = state.ReadUInt64();
					break;
				case 2:
					num2 = state.ReadUInt64();
					break;
				default:
					state.SkipField();
					break;
				}
			}
			if (num == 0 && num2 == 0)
			{
				return default(Guid);
			}
			if (s_guidOptimized)
			{
				return new GuidAccessor(num, num2).Guid;
			}
			uint num4 = (uint)(num >> 32);
			uint a = (uint)num;
			uint num5 = (uint)(num2 >> 32);
			uint num6 = (uint)num2;
			return new Guid((int)a, (short)num4, (short)(num4 >> 16), (byte)num6, (byte)(num6 >> 8), (byte)(num6 >> 16), (byte)(num6 >> 24), (byte)num5, (byte)(num5 >> 8), (byte)(num5 >> 16), (byte)(num5 >> 24));
		}

		void ISerializer<Guid>.Write(ref ProtoWriter.State state, Guid value)
		{
			if (!(value == Guid.Empty))
			{
				if (s_guidOptimized)
				{
					GuidAccessor guidAccessor = new GuidAccessor(value);
					state.WriteFieldHeader(1, WireType.Fixed64);
					state.WriteUInt64(guidAccessor.Low);
					state.WriteFieldHeader(2, WireType.Fixed64);
					state.WriteUInt64(guidAccessor.High);
				}
				else
				{
					byte[] array = value.ToByteArray();
					state.WriteFieldHeader(1, WireType.Fixed64);
					state.WriteBytes(new ReadOnlyMemory<byte>(array, 0, 8));
					state.WriteFieldHeader(2, WireType.Fixed64);
					state.WriteBytes(new ReadOnlyMemory<byte>(array, 8, 8));
				}
			}
		}

		private static bool VerifyGuidLayout()
		{
			try
			{
				if (!Guid.TryParse("12345678-2345-3456-4567-56789a6789ab", out var result))
				{
					return false;
				}
				GuidAccessor guidAccessor = new GuidAccessor(result);
				ulong low = guidAccessor.Low;
				ulong high = guidAccessor.High;
				if (low != 3771240517534504568L || high != 12360524565436589893uL)
				{
					return false;
				}
				byte[] array = result.ToByteArray();
				for (int i = 0; i < 8; i++)
				{
					if (array[i] != (byte)(low >> 8 * i))
					{
						return false;
					}
				}
				for (int j = 0; j < 8; j++)
				{
					if (array[j + 8] != (byte)(high >> 8 * j))
					{
						return false;
					}
				}
				return true;
			}
			catch
			{
			}
			return false;
		}

		string ISerializer<string>.Read(ref ProtoReader.State state, string value)
		{
			return state.ReadString();
		}

		void ISerializer<string>.Write(ref ProtoWriter.State state, string value)
		{
			state.WriteString(value);
		}

		int IMeasuringSerializer<string>.Measure(ISerializationContext context, WireType wireType, string value)
		{
			if (wireType == WireType.String)
			{
				return ProtoWriter.UTF8.GetByteCount(value);
			}
			return -1;
		}

		int ISerializer<int>.Read(ref ProtoReader.State state, int value)
		{
			return state.ReadInt32();
		}

		void ISerializer<int>.Write(ref ProtoWriter.State state, int value)
		{
			state.WriteInt32(value);
		}

		int IMeasuringSerializer<int>.Measure(ISerializationContext context, WireType wireType, int value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => (value < 0) ? 10 : ProtoWriter.MeasureUInt32((uint)value), 
				WireType.SignedVariant => ProtoWriter.MeasureUInt32(ProtoWriter.Zig(value)), 
				_ => -1, 
			};
		}

		byte[] ISerializer<byte[]>.Read(ref ProtoReader.State state, byte[] value)
		{
			return state.AppendBytes(value);
		}

		void ISerializer<byte[]>.Write(ref ProtoWriter.State state, byte[] value)
		{
			state.WriteBytes(value);
		}

		int IMeasuringSerializer<byte[]>.Measure(ISerializationContext context, WireType wireType, byte[] value)
		{
			if (wireType == WireType.String)
			{
				return value.Length;
			}
			return -1;
		}

		ArraySegment<byte> ISerializer<ArraySegment<byte>>.Read(ref ProtoReader.State state, ArraySegment<byte> value)
		{
			return state.AppendBytes(value);
		}

		void ISerializer<ArraySegment<byte>>.Write(ref ProtoWriter.State state, ArraySegment<byte> value)
		{
			state.WriteBytes(value);
		}

		int IMeasuringSerializer<ArraySegment<byte>>.Measure(ISerializationContext context, WireType wireType, ArraySegment<byte> value)
		{
			if (wireType == WireType.String)
			{
				return value.Count;
			}
			return -1;
		}

		Memory<byte> ISerializer<Memory<byte>>.Read(ref ProtoReader.State state, Memory<byte> value)
		{
			return state.AppendBytes(value);
		}

		void ISerializer<Memory<byte>>.Write(ref ProtoWriter.State state, Memory<byte> value)
		{
			state.WriteBytes(value);
		}

		int IMeasuringSerializer<Memory<byte>>.Measure(ISerializationContext context, WireType wireType, Memory<byte> value)
		{
			if (wireType == WireType.String)
			{
				return value.Length;
			}
			return -1;
		}

		ReadOnlyMemory<byte> ISerializer<ReadOnlyMemory<byte>>.Read(ref ProtoReader.State state, ReadOnlyMemory<byte> value)
		{
			return state.AppendBytes(value);
		}

		void ISerializer<ReadOnlyMemory<byte>>.Write(ref ProtoWriter.State state, ReadOnlyMemory<byte> value)
		{
			state.WriteBytes(value);
		}

		int IMeasuringSerializer<ReadOnlyMemory<byte>>.Measure(ISerializationContext context, WireType wireType, ReadOnlyMemory<byte> value)
		{
			if (wireType == WireType.String)
			{
				return value.Length;
			}
			return -1;
		}

		byte ISerializer<byte>.Read(ref ProtoReader.State state, byte value)
		{
			return state.ReadByte();
		}

		void ISerializer<byte>.Write(ref ProtoWriter.State state, byte value)
		{
			state.WriteByte(value);
		}

		int IMeasuringSerializer<byte>.Measure(ISerializationContext context, WireType wireType, byte value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => ProtoWriter.MeasureUInt32(value), 
				_ => -1, 
			};
		}

		ushort ISerializer<ushort>.Read(ref ProtoReader.State state, ushort value)
		{
			return state.ReadUInt16();
		}

		void ISerializer<ushort>.Write(ref ProtoWriter.State state, ushort value)
		{
			state.WriteUInt16(value);
		}

		int IMeasuringSerializer<ushort>.Measure(ISerializationContext context, WireType wireType, ushort value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => ProtoWriter.MeasureUInt32(value), 
				_ => -1, 
			};
		}

		uint ISerializer<uint>.Read(ref ProtoReader.State state, uint value)
		{
			return state.ReadUInt32();
		}

		void ISerializer<uint>.Write(ref ProtoWriter.State state, uint value)
		{
			state.WriteUInt32(value);
		}

		int IMeasuringSerializer<uint>.Measure(ISerializationContext context, WireType wireType, uint value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => ProtoWriter.MeasureUInt32(value), 
				_ => -1, 
			};
		}

		ulong ISerializer<ulong>.Read(ref ProtoReader.State state, ulong value)
		{
			return state.ReadUInt64();
		}

		void ISerializer<ulong>.Write(ref ProtoWriter.State state, ulong value)
		{
			state.WriteUInt64(value);
		}

		int IMeasuringSerializer<ulong>.Measure(ISerializationContext context, WireType wireType, ulong value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => ProtoWriter.MeasureUInt64(value), 
				_ => -1, 
			};
		}

		long ISerializer<long>.Read(ref ProtoReader.State state, long value)
		{
			return state.ReadInt64();
		}

		void ISerializer<long>.Write(ref ProtoWriter.State state, long value)
		{
			state.WriteInt64(value);
		}

		int IMeasuringSerializer<long>.Measure(ISerializationContext context, WireType wireType, long value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => ProtoWriter.MeasureUInt64((ulong)value), 
				WireType.SignedVariant => ProtoWriter.MeasureUInt64(ProtoWriter.Zig(value)), 
				_ => -1, 
			};
		}

		bool ISerializer<bool>.Read(ref ProtoReader.State state, bool value)
		{
			return state.ReadBoolean();
		}

		void ISerializer<bool>.Write(ref ProtoWriter.State state, bool value)
		{
			state.WriteBoolean(value);
		}

		int IMeasuringSerializer<bool>.Measure(ISerializationContext context, WireType wireType, bool value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => 1, 
				_ => -1, 
			};
		}

		float ISerializer<float>.Read(ref ProtoReader.State state, float value)
		{
			return state.ReadSingle();
		}

		void ISerializer<float>.Write(ref ProtoWriter.State state, float value)
		{
			state.WriteSingle(value);
		}

		int IMeasuringSerializer<float>.Measure(ISerializationContext context, WireType wireType, float value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				_ => -1, 
			};
		}

		double ISerializer<double>.Read(ref ProtoReader.State state, double value)
		{
			return state.ReadDouble();
		}

		void ISerializer<double>.Write(ref ProtoWriter.State state, double value)
		{
			state.WriteDouble(value);
		}

		int IMeasuringSerializer<double>.Measure(ISerializationContext context, WireType wireType, double value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				_ => -1, 
			};
		}

		sbyte ISerializer<sbyte>.Read(ref ProtoReader.State state, sbyte value)
		{
			return state.ReadSByte();
		}

		void ISerializer<sbyte>.Write(ref ProtoWriter.State state, sbyte value)
		{
			state.WriteSByte(value);
		}

		int IMeasuringSerializer<sbyte>.Measure(ISerializationContext context, WireType wireType, sbyte value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => (value < 0) ? 10 : ProtoWriter.MeasureUInt32((uint)value), 
				WireType.SignedVariant => ProtoWriter.MeasureUInt32(ProtoWriter.Zig(value)), 
				_ => -1, 
			};
		}

		short ISerializer<short>.Read(ref ProtoReader.State state, short value)
		{
			return state.ReadInt16();
		}

		void ISerializer<short>.Write(ref ProtoWriter.State state, short value)
		{
			state.WriteInt16(value);
		}

		int IMeasuringSerializer<short>.Measure(ISerializationContext context, WireType wireType, short value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => (value < 0) ? 10 : ProtoWriter.MeasureUInt32((uint)value), 
				WireType.SignedVariant => ProtoWriter.MeasureUInt32(ProtoWriter.Zig(value)), 
				_ => -1, 
			};
		}

		Uri ISerializer<Uri>.Read(ref ProtoReader.State state, Uri value)
		{
			string text = state.ReadString();
			if (!string.IsNullOrEmpty(text))
			{
				return new Uri(text, UriKind.RelativeOrAbsolute);
			}
			return null;
		}

		void ISerializer<Uri>.Write(ref ProtoWriter.State state, Uri value)
		{
			state.WriteString(value.OriginalString);
		}

		int IMeasuringSerializer<Uri>.Measure(ISerializationContext context, WireType wireType, Uri value)
		{
			if (wireType == WireType.String)
			{
				return ProtoWriter.UTF8.GetByteCount(value.OriginalString);
			}
			return -1;
		}

		char ISerializer<char>.Read(ref ProtoReader.State state, char value)
		{
			return (char)state.ReadUInt16();
		}

		void ISerializer<char>.Write(ref ProtoWriter.State state, char value)
		{
			state.WriteUInt16(value);
		}

		int IMeasuringSerializer<char>.Measure(ISerializationContext context, WireType wireType, char value)
		{
			return wireType switch
			{
				WireType.Fixed32 => 4, 
				WireType.Fixed64 => 8, 
				WireType.Variant => ProtoWriter.MeasureUInt32(value), 
				_ => -1, 
			};
		}

		string IFactory<string>.Create(ISerializationContext context)
		{
			return "";
		}

		byte[] IFactory<byte[]>.Create(ISerializationContext context)
		{
			return Array.Empty<byte>();
		}

		void ISerializer<int?>.Write(ref ProtoWriter.State state, int? value)
		{
			((ISerializer<int>)this).Write(ref state, value.Value);
		}

		int? ISerializer<int?>.Read(ref ProtoReader.State state, int? value)
		{
			return ((ISerializer<int>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<short?>.Write(ref ProtoWriter.State state, short? value)
		{
			((ISerializer<short>)this).Write(ref state, value.Value);
		}

		short? ISerializer<short?>.Read(ref ProtoReader.State state, short? value)
		{
			return ((ISerializer<short>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<long?>.Write(ref ProtoWriter.State state, long? value)
		{
			((ISerializer<long>)this).Write(ref state, value.Value);
		}

		long? ISerializer<long?>.Read(ref ProtoReader.State state, long? value)
		{
			return ((ISerializer<long>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<sbyte?>.Write(ref ProtoWriter.State state, sbyte? value)
		{
			((ISerializer<sbyte>)this).Write(ref state, value.Value);
		}

		sbyte? ISerializer<sbyte?>.Read(ref ProtoReader.State state, sbyte? value)
		{
			return ((ISerializer<sbyte>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<uint?>.Write(ref ProtoWriter.State state, uint? value)
		{
			((ISerializer<uint>)this).Write(ref state, value.Value);
		}

		uint? ISerializer<uint?>.Read(ref ProtoReader.State state, uint? value)
		{
			return ((ISerializer<uint>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<ushort?>.Write(ref ProtoWriter.State state, ushort? value)
		{
			((ISerializer<ushort>)this).Write(ref state, value.Value);
		}

		ushort? ISerializer<ushort?>.Read(ref ProtoReader.State state, ushort? value)
		{
			return ((ISerializer<ushort>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<ulong?>.Write(ref ProtoWriter.State state, ulong? value)
		{
			((ISerializer<ulong>)this).Write(ref state, value.Value);
		}

		ulong? ISerializer<ulong?>.Read(ref ProtoReader.State state, ulong? value)
		{
			return ((ISerializer<ulong>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<byte?>.Write(ref ProtoWriter.State state, byte? value)
		{
			((ISerializer<byte>)this).Write(ref state, value.Value);
		}

		byte? ISerializer<byte?>.Read(ref ProtoReader.State state, byte? value)
		{
			return ((ISerializer<byte>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<char?>.Write(ref ProtoWriter.State state, char? value)
		{
			((ISerializer<char>)this).Write(ref state, value.Value);
		}

		char? ISerializer<char?>.Read(ref ProtoReader.State state, char? value)
		{
			return ((ISerializer<char>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<bool?>.Write(ref ProtoWriter.State state, bool? value)
		{
			((ISerializer<bool>)this).Write(ref state, value.Value);
		}

		bool? ISerializer<bool?>.Read(ref ProtoReader.State state, bool? value)
		{
			return ((ISerializer<bool>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<float?>.Write(ref ProtoWriter.State state, float? value)
		{
			((ISerializer<float>)this).Write(ref state, value.Value);
		}

		float? ISerializer<float?>.Read(ref ProtoReader.State state, float? value)
		{
			return ((ISerializer<float>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<double?>.Write(ref ProtoWriter.State state, double? value)
		{
			((ISerializer<double>)this).Write(ref state, value.Value);
		}

		double? ISerializer<double?>.Read(ref ProtoReader.State state, double? value)
		{
			return ((ISerializer<double>)this).Read(ref state, value.GetValueOrDefault());
		}

		Type ISerializer<Type>.Read(ref ProtoReader.State state, Type value)
		{
			return state.ReadType();
		}

		void ISerializer<Type>.Write(ref ProtoWriter.State state, Type value)
		{
			state.WriteType(value);
		}

		int IMeasuringSerializer<Type>.Measure(ISerializationContext context, WireType wireType, Type value)
		{
			if (wireType == WireType.String)
			{
				return Encoding.UTF8.GetByteCount(TypeModel.SerializeType(context?.Model, value));
			}
			return -1;
		}

		bool IValueChecker<string>.HasNonTrivialValue(string value)
		{
			return value != null;
		}

		bool IValueChecker<Uri>.HasNonTrivialValue(Uri value)
		{
			return value?.OriginalString != null;
		}

		bool IValueChecker<Type>.HasNonTrivialValue(Type value)
		{
			return (object)value != null;
		}

		bool IValueChecker<byte[]>.HasNonTrivialValue(byte[] value)
		{
			return value != null;
		}

		bool IValueChecker<sbyte>.HasNonTrivialValue(sbyte value)
		{
			return value != 0;
		}

		bool IValueChecker<short>.HasNonTrivialValue(short value)
		{
			return value != 0;
		}

		bool IValueChecker<int>.HasNonTrivialValue(int value)
		{
			return value != 0;
		}

		bool IValueChecker<long>.HasNonTrivialValue(long value)
		{
			return value != 0;
		}

		bool IValueChecker<byte>.HasNonTrivialValue(byte value)
		{
			return value != 0;
		}

		bool IValueChecker<ushort>.HasNonTrivialValue(ushort value)
		{
			return value != 0;
		}

		bool IValueChecker<uint>.HasNonTrivialValue(uint value)
		{
			return value != 0;
		}

		bool IValueChecker<ulong>.HasNonTrivialValue(ulong value)
		{
			return value != 0;
		}

		bool IValueChecker<char>.HasNonTrivialValue(char value)
		{
			return value != '\0';
		}

		bool IValueChecker<bool>.HasNonTrivialValue(bool value)
		{
			return value;
		}

		bool IValueChecker<float>.HasNonTrivialValue(float value)
		{
			return value != 0f;
		}

		bool IValueChecker<double>.HasNonTrivialValue(double value)
		{
			return value != 0.0;
		}

		bool IValueChecker<sbyte>.IsNull(sbyte value)
		{
			return false;
		}

		bool IValueChecker<short>.IsNull(short value)
		{
			return false;
		}

		bool IValueChecker<int>.IsNull(int value)
		{
			return false;
		}

		bool IValueChecker<long>.IsNull(long value)
		{
			return false;
		}

		bool IValueChecker<byte>.IsNull(byte value)
		{
			return false;
		}

		bool IValueChecker<ushort>.IsNull(ushort value)
		{
			return false;
		}

		bool IValueChecker<uint>.IsNull(uint value)
		{
			return false;
		}

		bool IValueChecker<ulong>.IsNull(ulong value)
		{
			return false;
		}

		bool IValueChecker<char>.IsNull(char value)
		{
			return false;
		}

		bool IValueChecker<bool>.IsNull(bool value)
		{
			return false;
		}

		bool IValueChecker<float>.IsNull(float value)
		{
			return false;
		}

		bool IValueChecker<double>.IsNull(double value)
		{
			return false;
		}

		bool IValueChecker<string>.IsNull(string value)
		{
			return value == null;
		}

		bool IValueChecker<byte[]>.IsNull(byte[] value)
		{
			return value == null;
		}

		bool IValueChecker<Uri>.IsNull(Uri value)
		{
			return (object)value == null;
		}

		bool IValueChecker<Type>.IsNull(Type value)
		{
			return (object)value == null;
		}

		bool IValueChecker<int?>.HasNonTrivialValue(int? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<int?>.IsNull(int? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<uint?>.HasNonTrivialValue(uint? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<uint?>.IsNull(uint? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<short?>.HasNonTrivialValue(short? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<short?>.IsNull(short? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<ushort?>.HasNonTrivialValue(ushort? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<ushort?>.IsNull(ushort? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<long?>.HasNonTrivialValue(long? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<long?>.IsNull(long? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<ulong?>.HasNonTrivialValue(ulong? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<ulong?>.IsNull(ulong? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<float?>.HasNonTrivialValue(float? value)
		{
			return value.GetValueOrDefault() != 0f;
		}

		bool IValueChecker<float?>.IsNull(float? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<double?>.HasNonTrivialValue(double? value)
		{
			return value.GetValueOrDefault() != 0.0;
		}

		bool IValueChecker<double?>.IsNull(double? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<byte?>.HasNonTrivialValue(byte? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<byte?>.IsNull(byte? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<sbyte?>.HasNonTrivialValue(sbyte? value)
		{
			return value.GetValueOrDefault() != 0;
		}

		bool IValueChecker<sbyte?>.IsNull(sbyte? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<bool?>.HasNonTrivialValue(bool? value)
		{
			return value.GetValueOrDefault();
		}

		bool IValueChecker<bool?>.IsNull(bool? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<char?>.HasNonTrivialValue(char? value)
		{
			return value.GetValueOrDefault() != '\0';
		}

		bool IValueChecker<char?>.IsNull(char? value)
		{
			return !value.HasValue;
		}

		int IMeasuringSerializer<int?>.Measure(ISerializationContext context, WireType wireType, int? value)
		{
			return ((IMeasuringSerializer<int>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<long?>.Measure(ISerializationContext context, WireType wireType, long? value)
		{
			return ((IMeasuringSerializer<long>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<float?>.Measure(ISerializationContext context, WireType wireType, float? value)
		{
			return ((IMeasuringSerializer<float>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<double?>.Measure(ISerializationContext context, WireType wireType, double? value)
		{
			return ((IMeasuringSerializer<double>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<byte?>.Measure(ISerializationContext context, WireType wireType, byte? value)
		{
			return ((IMeasuringSerializer<byte>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<ushort?>.Measure(ISerializationContext context, WireType wireType, ushort? value)
		{
			return ((IMeasuringSerializer<ushort>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<uint?>.Measure(ISerializationContext context, WireType wireType, uint? value)
		{
			return ((IMeasuringSerializer<uint>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<ulong?>.Measure(ISerializationContext context, WireType wireType, ulong? value)
		{
			return ((IMeasuringSerializer<ulong>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<sbyte?>.Measure(ISerializationContext context, WireType wireType, sbyte? value)
		{
			return ((IMeasuringSerializer<sbyte>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<short?>.Measure(ISerializationContext context, WireType wireType, short? value)
		{
			return ((IMeasuringSerializer<short>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<char?>.Measure(ISerializationContext context, WireType wireType, char? value)
		{
			return ((IMeasuringSerializer<char>)this).Measure(context, wireType, value.Value);
		}

		int IMeasuringSerializer<bool?>.Measure(ISerializationContext context, WireType wireType, bool? value)
		{
			return ((IMeasuringSerializer<bool>)this).Measure(context, wireType, value.Value);
		}

		void ISerializer<IntPtr?>.Write(ref ProtoWriter.State state, IntPtr? value)
		{
			((ISerializer<IntPtr>)this).Write(ref state, value.Value);
		}

		IntPtr? ISerializer<IntPtr?>.Read(ref ProtoReader.State state, IntPtr? value)
		{
			return ((ISerializer<IntPtr>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<UIntPtr?>.Write(ref ProtoWriter.State state, UIntPtr? value)
		{
			((ISerializer<UIntPtr>)this).Write(ref state, value.Value);
		}

		UIntPtr? ISerializer<UIntPtr?>.Read(ref ProtoReader.State state, UIntPtr? value)
		{
			return ((ISerializer<UIntPtr>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<IntPtr>.Write(ref ProtoWriter.State state, IntPtr value)
		{
			state.WriteIntPtr(value);
		}

		IntPtr ISerializer<IntPtr>.Read(ref ProtoReader.State state, IntPtr value)
		{
			return state.ReadIntPtr();
		}

		void ISerializer<UIntPtr>.Write(ref ProtoWriter.State state, UIntPtr value)
		{
			state.WriteUIntPtr(value);
		}

		UIntPtr ISerializer<UIntPtr>.Read(ref ProtoReader.State state, UIntPtr value)
		{
			return state.ReadUIntPtr();
		}

		int IMeasuringSerializer<IntPtr>.Measure(ISerializationContext context, WireType wireType, IntPtr value)
		{
			return ((IMeasuringSerializer<long>)this).Measure(context, wireType, value.ToInt64());
		}

		int IMeasuringSerializer<UIntPtr>.Measure(ISerializationContext context, WireType wireType, UIntPtr value)
		{
			return ((IMeasuringSerializer<ulong>)this).Measure(context, wireType, value.ToUInt64());
		}

		int IMeasuringSerializer<IntPtr?>.Measure(ISerializationContext context, WireType wireType, IntPtr? value)
		{
			return ((IMeasuringSerializer<long>)this).Measure(context, wireType, value.Value.ToInt64());
		}

		int IMeasuringSerializer<UIntPtr?>.Measure(ISerializationContext context, WireType wireType, UIntPtr? value)
		{
			return ((IMeasuringSerializer<ulong>)this).Measure(context, wireType, value.Value.ToUInt64());
		}

		bool IValueChecker<IntPtr>.HasNonTrivialValue(IntPtr value)
		{
			return value != IntPtr.Zero;
		}

		bool IValueChecker<IntPtr>.IsNull(IntPtr value)
		{
			return false;
		}

		bool IValueChecker<UIntPtr>.HasNonTrivialValue(UIntPtr value)
		{
			return value != UIntPtr.Zero;
		}

		bool IValueChecker<UIntPtr>.IsNull(UIntPtr value)
		{
			return false;
		}

		bool IValueChecker<IntPtr?>.HasNonTrivialValue(IntPtr? value)
		{
			return value.GetValueOrDefault() != IntPtr.Zero;
		}

		bool IValueChecker<IntPtr?>.IsNull(IntPtr? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<UIntPtr?>.HasNonTrivialValue(UIntPtr? value)
		{
			return value.GetValueOrDefault() != UIntPtr.Zero;
		}

		bool IValueChecker<UIntPtr?>.IsNull(UIntPtr? value)
		{
			return !value.HasValue;
		}

		TimeSpan? ISerializer<TimeSpan?>.Read(ref ProtoReader.State state, TimeSpan? value)
		{
			return ((ISerializer<TimeSpan>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<TimeSpan?>.Write(ref ProtoWriter.State state, TimeSpan? value)
		{
			((ISerializer<TimeSpan>)this).Write(ref state, value.Value);
		}

		DateTime? ISerializer<DateTime?>.Read(ref ProtoReader.State state, DateTime? value)
		{
			return ((ISerializer<DateTime>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<DateTime?>.Write(ref ProtoWriter.State state, DateTime? value)
		{
			((ISerializer<DateTime>)this).Write(ref state, value.Value);
		}

		TimeSpan ISerializer<TimeSpan>.Read(ref ProtoReader.State state, TimeSpan value)
		{
			return ((ISerializer<ScaledTicks>)this).Read(ref state, default(ScaledTicks)).ToTimeSpan();
		}

		void ISerializer<TimeSpan>.Write(ref ProtoWriter.State state, TimeSpan value)
		{
			((ISerializer<ScaledTicks>)this).Write(ref state, new ScaledTicks(value, DateTimeKind.Unspecified));
		}

		DateTime ISerializer<DateTime>.Read(ref ProtoReader.State state, DateTime value)
		{
			return ((ISerializer<ScaledTicks>)this).Read(ref state, default(ScaledTicks)).ToDateTime();
		}

		void ISerializer<DateTime>.Write(ref ProtoWriter.State state, DateTime value)
		{
			bool includeKind = state.Model.HasOption(TypeModel.TypeModelOptions.IncludeDateTimeKind);
			((ISerializer<ScaledTicks>)this).Write(ref state, ScaledTicks.Create(value, includeKind));
		}

		void ISerializer<ScaledTicks>.Write(ref ProtoWriter.State state, ScaledTicks value)
		{
			if (value.Value != 0L)
			{
				state.WriteFieldHeader(1, WireType.SignedVariant);
				state.WriteInt64(value.Value);
			}
			if (value.Scale != 0)
			{
				state.WriteFieldHeader(2, WireType.Variant);
				state.WriteInt32((int)value.Scale);
			}
			if (value.Kind != 0)
			{
				state.WriteFieldHeader(3, WireType.Variant);
				state.WriteInt32((int)value.Kind);
			}
		}

		ScaledTicks ISerializer<ScaledTicks>.Read(ref ProtoReader.State state, ScaledTicks _)
		{
			TimeSpanScale scale = TimeSpanScale.Days;
			long value = 0L;
			DateTimeKind dateTimeKind = DateTimeKind.Unspecified;
			int num;
			while ((num = state.ReadFieldHeader()) > 0)
			{
				switch (num)
				{
				case 2:
					scale = (TimeSpanScale)state.ReadInt32();
					break;
				case 1:
					state.Assert(WireType.SignedVariant);
					value = state.ReadInt64();
					break;
				case 3:
					dateTimeKind = (DateTimeKind)state.ReadInt32();
					if ((uint)dateTimeKind > 2u)
					{
						ThrowHelper.ThrowProtoException("Invalid date/time kind: " + dateTimeKind);
					}
					break;
				default:
					state.SkipField();
					break;
				}
			}
			return new ScaledTicks(value, scale, dateTimeKind);
		}

		Duration? ISerializer<Duration?>.Read(ref ProtoReader.State state, Duration? value)
		{
			return ((ISerializer<Duration>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<Duration?>.Write(ref ProtoWriter.State state, Duration? value)
		{
			((ISerializer<Duration>)this).Write(ref state, value.Value);
		}

		Duration ISerializer<Duration>.Read(ref ProtoReader.State state, Duration value)
		{
			return ReadDuration(ref state, value);
		}

		internal static Duration ReadDuration(ref ProtoReader.State state, Duration value)
		{
			if (state.WireType == WireType.String && state.RemainingInCurrent >= 20 && TryReadDurationFast(ref state, ref value))
			{
				return value;
			}
			return ReadDurationFallback(ref state, value);
		}

		private static bool TryReadDurationFast(ref ProtoReader.State state, ref Duration value)
		{
			int offsetInCurrent = state.OffsetInCurrent;
			ReadOnlySpan<byte> span = state.Span;
			uint value2;
			int num = state.ParseVarintUInt32(span, offsetInCurrent, out value2);
			offsetInCurrent += num;
			if (value2 == 0)
			{
				return true;
			}
			if (num + value2 > state.RemainingInCurrent)
			{
				return false;
			}
			if (span[offsetInCurrent] != 8)
			{
				return false;
			}
			ulong value3;
			int num2 = 1 + ProtoReader.State.TryParseUInt64Varint(span, 1 + offsetInCurrent, out value3);
			int nanoseconds = value.Nanoseconds;
			if (num2 < value2)
			{
				if (span[num2++ + offsetInCurrent] != 16)
				{
					return false;
				}
				num2 += ProtoReader.State.TryParseUInt64Varint(span, num2 + offsetInCurrent, out var value4);
				nanoseconds = (int)value4;
			}
			if (num2 != value2)
			{
				return false;
			}
			state.Skip(num + (int)value2);
			state.Advance(num + value2);
			value = new Duration((long)value3, nanoseconds);
			return true;
		}

		private static Duration ReadDurationFallback(ref ProtoReader.State state, Duration value)
		{
			long seconds = value.Seconds;
			int nanoseconds = value.Nanoseconds;
			int num;
			while ((num = state.ReadFieldHeader()) > 0)
			{
				switch (num)
				{
				case 1:
					seconds = state.ReadInt64();
					break;
				case 2:
					nanoseconds = state.ReadInt32();
					break;
				default:
					state.SkipField();
					break;
				}
			}
			return new Duration(seconds, nanoseconds);
		}

		void ISerializer<Duration>.Write(ref ProtoWriter.State state, Duration value)
		{
			WriteSecondsNanos(ref state, value.Seconds, value.Nanoseconds, isTimestamp: false);
		}

		internal static void WriteDuration(ref ProtoWriter.State state, Duration value)
		{
			WriteSecondsNanos(ref state, value.Seconds, value.Nanoseconds, isTimestamp: false);
		}

		internal static long ToDurationSeconds(TimeSpan value, out int nanos, bool isTimestamp)
		{
			nanos = (int)(value.Ticks % 10000000 * 1000000 / 10000);
			long seconds = value.Ticks / 10000000;
			NormalizeSecondsNanoseconds(ref seconds, ref nanos, isTimestamp);
			return seconds;
		}

		internal static long ToTicks(long seconds, int nanos)
		{
			checked
			{
				return seconds * 10000000 + unchecked(checked(unchecked((long)nanos) * 10000L) / 1000000);
			}
		}

		internal static void NormalizeSecondsNanoseconds(ref long seconds, ref int nanos, bool isTimestamp)
		{
			seconds += nanos / 1000000000;
			nanos %= 1000000000;
			if (isTimestamp)
			{
				if (nanos < 0)
				{
					seconds--;
					nanos += 1000000000;
				}
				return;
			}
			if (nanos < 0 && seconds >= 0)
			{
				seconds--;
				nanos += 1000000000;
			}
			if (nanos > 0 && seconds < 0)
			{
				nanos -= 1000000000;
				seconds++;
			}
		}

		private static void WriteSecondsNanos(ref ProtoWriter.State state, long seconds, int nanos, bool isTimestamp)
		{
			NormalizeSecondsNanoseconds(ref seconds, ref nanos, isTimestamp);
			if (seconds != 0L)
			{
				state.WriteFieldHeader(1, WireType.Variant);
				state.WriteInt64(seconds);
			}
			if (nanos != 0)
			{
				state.WriteFieldHeader(2, WireType.Variant);
				state.WriteInt32(nanos);
			}
		}

		Empty ISerializer<Empty>.Read(ref ProtoReader.State state, Empty value)
		{
			state.SkipAllFields();
			return value;
		}

		void ISerializer<Empty>.Write(ref ProtoWriter.State state, Empty value)
		{
		}

		Empty? ISerializer<Empty?>.Read(ref ProtoReader.State state, Empty? value)
		{
			return ((ISerializer<Empty>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<Empty?>.Write(ref ProtoWriter.State state, Empty? value)
		{
			((ISerializer<Empty>)this).Write(ref state, value.Value);
		}

		Timestamp ISerializer<Timestamp>.Read(ref ProtoReader.State state, Timestamp value)
		{
			Duration value2 = new Duration(value.Seconds, value.Nanoseconds);
			value2 = ReadDuration(ref state, value2);
			return new Timestamp(value2.Seconds, value2.Nanoseconds);
		}

		internal static Timestamp ReadTimestamp(ref ProtoReader.State state, Timestamp value)
		{
			Duration value2 = new Duration(value.Seconds, value.Nanoseconds);
			value2 = ReadDuration(ref state, value2);
			return new Timestamp(value2.Seconds, value2.Nanoseconds);
		}

		void ISerializer<Timestamp>.Write(ref ProtoWriter.State state, Timestamp value)
		{
			WriteSecondsNanos(ref state, value.Seconds, value.Nanoseconds, isTimestamp: true);
		}

		internal static void WriteTimestamp(ref ProtoWriter.State state, Timestamp value)
		{
			WriteSecondsNanos(ref state, value.Seconds, value.Nanoseconds, isTimestamp: true);
		}

		Timestamp? ISerializer<Timestamp?>.Read(ref ProtoReader.State state, Timestamp? value)
		{
			return ((ISerializer<Timestamp>)this).Read(ref state, value.GetValueOrDefault());
		}

		void ISerializer<Timestamp?>.Write(ref ProtoWriter.State state, Timestamp? value)
		{
			((ISerializer<Timestamp>)this).Write(ref state, value.Value);
		}
	}
	[StructLayout(LayoutKind.Auto)]
	internal struct ReadBuffer<T> : IDisposable, ICollection<T>, IEnumerable<T>, IEnumerable, IReadOnlyCollection<T>, ICollection
	{
		private T[] _arr;

		private int _count;

		bool ICollection<T>.IsReadOnly => false;

		bool ICollection.IsSynchronized => false;

		object ICollection.SyncRoot => _arr;

		public bool IsEmpty => _count == 0;

		public int Count => _count;

		public ArraySegment<T> Segment => new ArraySegment<T>(_arr, 0, _count);

		public Span<T> Span => new Span<T>(_arr, 0, _count);

		public void Clear()
		{
			_count = 0;
		}

		public void CopyTo(T[] array, int arrayIndex = 0)
		{
			Array.Copy(_arr, 0, array, arrayIndex, _count);
		}

		void ICollection.CopyTo(Array array, int index)
		{
			Array.Copy(_arr, 0, array, index, _count);
		}

		public T[] ToArray()
		{
			if (_count == 0)
			{
				return Array.Empty<T>();
			}
			T[] array = new T[_count];
			CopyTo(array);
			return array;
		}

		public T[] ToArray(T[] prepend)
		{
			int num = ((prepend != null) ? prepend.Length : 0);
			if (num == 0)
			{
				return ToArray();
			}
			if (_count == 0)
			{
				return prepend ?? Array.Empty<T>();
			}
			T[] array = new T[num + _count];
			Array.Copy(prepend, 0, array, 0, num);
			Array.Copy(_arr, 0, array, num, _count);
			return array;
		}

		bool ICollection<T>.Contains(T item)
		{
			return Array.IndexOf(_arr, item, 0, _count) >= 0;
		}

		bool ICollection<T>.Remove(T item)
		{
			int num = Array.IndexOf(_arr, item, 0, _count);
			if (num < 0)
			{
				return false;
			}
			_count--;
			Array.Copy(_arr, num + 1, _arr, num, _count - num);
			return true;
		}

		public IEnumerator<T> GetEnumerator()
		{
			return _arr.Take(_count).GetEnumerator();
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return GetEnumerator();
		}

		private ReadBuffer(int minimumLength)
		{
			_arr = ArrayPool<T>.Shared.Rent(minimumLength);
			_count = 0;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static ReadBuffer<T> Create(int minimumLength = 16)
		{
			return new ReadBuffer<T>(minimumLength);
		}

		private static void Recyle(ref T[] array)
		{
			if (array != null)
			{
				bool clearArray = !typeof(T).IsValueType;
				ArrayPool<T>.Shared.Return(array, clearArray);
				array = null;
			}
		}

		public void Dispose()
		{
			_count = 0;
			Recyle(ref _arr);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		private void Grow()
		{
			uint num = (uint)_arr.Length;
			uint num2 = Math.Min(num * 2, 2146435071u);
			if (num == num2)
			{
				ThrowHelper.ThrowInvalidOperationException("maximum array size exceeded");
			}
			T[] array = ArrayPool<T>.Shared.Rent((int)num2);
			Array.Copy(_arr, 0, array, 0, _arr.Length);
			Recyle(ref _arr);
			_arr = array;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public void Add(T value)
		{
			int num = _count++;
			if (num == _arr.Length)
			{
				Grow();
			}
			_arr[num] = value;
		}
	}
	internal static class ThrowHelper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName)
		{
			throw new ArgumentOutOfRangeException(paramName);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentOutOfRangeException(string paramName, string message)
		{
			throw new ArgumentOutOfRangeException(paramName, message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentNullException(string paramName)
		{
			throw new ArgumentNullException(paramName);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowArgumentNullException(string paramName, string message)
		{
			throw new ArgumentNullException(paramName, message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		public static void ThrowIndexOutOfRangeException()
		{
			throw new IndexOutOfRangeException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowArgumentException(string message, string paramName)
		{
			throw new ArgumentException(message, paramName);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void Format(string message)
		{
			throw new FormatException(message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowArgumentException(string message)
		{
			throw new ArgumentException(message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowInvalidOperationException_InvalidOperation_EnumFailedVersion()
		{
			throw new InvalidOperationException("Collection was modified; enumeration operation may not execute.");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowInvalidOperationException(string message = null, Exception innerException = null)
		{
			if (string.IsNullOrWhiteSpace(message))
			{
				if (innerException == null)
				{
					throw new InvalidOperationException();
				}
				throw new InvalidOperationException(innerException.Message, innerException);
			}
			if (innerException == null)
			{
				throw new InvalidOperationException(message);
			}
			throw new InvalidOperationException(message, innerException);
		}

		internal static void NoSerializerDefined(Type type)
		{
			InvalidOperationException ex = new InvalidOperationException("No serializer defined for type: " + type.NormalizeName());
			if ((object)type != null && type.FindInterfaces((Type i, object _) => i.FullName == "Google.Protobuf.IMessage", null).Length != 0)
			{
				try
				{
					throw ex;
				}
				catch (Exception innerException)
				{
					ex = new InvalidOperationException("Type '" + type.NormalizeName() + "' looks like a Google.Protobuf type; it cannot be used directly with protobuf-net without manual configuration; it may be possible to generate a protobuf-net type instead; see https://protobuf-net.github.io/protobuf-net/contract_first", innerException);
				}
			}
			throw ex;
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowNotSupportedException()
		{
			throw new NotSupportedException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowNotSupportedException(string message)
		{
			throw new NotSupportedException(message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowProtoException(string message, Exception inner = null)
		{
			throw (inner == null) ? new ProtoException(message) : new ProtoException(message, inner);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowOverflowException()
		{
			throw new OverflowException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowNotImplementedException([CallerMemberName] string message = null)
		{
			throw new NotImplementedException(message);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowNullReferenceException()
		{
			throw new NullReferenceException();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowNullRepeatedContents<T>()
		{
			throw new NullReferenceException("An element of type " + typeof(T).NormalizeName() + " was null; this might be as contents in a list/array");
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowTrackedObjects(object obj)
		{
			throw new NotSupportedException("tracked objects and featured related to stream rewriting are not supported on " + obj.GetType().Name);
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowNestedDataNotSupported(Type declaringType)
		{
			throw new NotSupportedException("Nested or jagged lists, arrays and maps are not supported: " + declaringType.NormalizeName());
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ThrowInvalidPackedOperationException(WireType wireType, Type type)
		{
			throw new ProtoException($"Invalid wire-type for packed encoding: {wireType}; processing {type.NormalizeName()}");
		}
	}
	internal static class TypeHelper
	{
		internal static string NormalizeName(this Type type)
		{
			return type?.ToString() ?? "(null)";
		}

		internal static bool CanBePacked(Type type)
		{
			type = Nullable.GetUnderlyingType(type) ?? type;
			if (type.IsEnum)
			{
				return true;
			}
			TypeCode typeCode = Type.GetTypeCode(type);
			if ((uint)(typeCode - 3) <= 11u)
			{
				return true;
			}
			return false;
		}

		internal static bool IsBytesLike(Type type)
		{
			if (type == typeof(byte[]))
			{
				return true;
			}
			if (type == typeof(Memory<byte>))
			{
				return true;
			}
			if (type == typeof(ReadOnlyMemory<byte>))
			{
				return true;
			}
			if (type == typeof(ArraySegment<byte>))
			{
				return true;
			}
			return false;
		}

		[Obsolete("Prefer list provider")]
		internal static bool ResolveUniqueEnumerableT(Type type, out Type t)
		{
			if ((object)type == null || type == typeof(string) || IsBytesLike(type) || type == typeof(object))
			{
				t = null;
				return false;
			}
			if (type.IsArray)
			{
				t = type.GetElementType();
				return type == t.MakeArrayType();
			}
			bool flag = false;
			t = null;
			try
			{
				if (IsEnumerableT(type, out t))
				{
					return true;
				}
				Type[] interfaces = type.GetInterfaces();
				foreach (Type type2 in interfaces)
				{
					if (IsEnumerableT(type2, out var t2))
					{
						if (flag && t2 != t)
						{
							flag = false;
							break;
						}
						flag = true;
						t = t2;
					}
				}
			}
			catch
			{
			}
			if (flag)
			{
				return true;
			}
			t = null;
			return false;
			static bool IsEnumerableT(Type type, out Type t)
			{
				if (type.IsInterface && type.IsGenericType && type.GetGenericTypeDefinition() == typeof(IEnumerable<>))
				{
					t = type.GetGenericArguments()[0];
					return true;
				}
				t = null;
				return false;
			}
		}

		internal static object GetValueTypeChecker(Type type)
		{
			Type type2 = Nullable.GetUnderlyingType(type) ?? type;
			return typeof(StructValueChecker<>).MakeGenericType(type2).GetField("Instance").GetValue(null);
		}

		internal static object CreateNonTrivialDefault(Type type)
		{
			if (type.IsValueType)
			{
				return Activator.CreateInstance(Nullable.GetUnderlyingType(type) ?? type);
			}
			if (type == typeof(string))
			{
				return "";
			}
			if (type == typeof(byte[]))
			{
				return Array.Empty<byte>();
			}
			return null;
		}
	}
	internal static class TypeHelper<T>
	{
		public static readonly bool IsReferenceType = !typeof(T).IsValueType;

		public static readonly bool CanBeNull = default(T) == null;

		public static readonly IValueChecker<T> ValueChecker = (SerializerCache<PrimaryTypeProvider>.InstanceField as IValueChecker<T>) ?? (ReferenceValueChecker.Instance as IValueChecker<T>) ?? ((IValueChecker<T>)TypeHelper.GetValueTypeChecker(typeof(T)));

		public static readonly bool CanBePacked = !IsReferenceType && TypeHelper.CanBePacked(typeof(T));

		public static readonly T Default = ((typeof(T) == typeof(string)) ? ((T)(object)"") : default(T));

		public static readonly T NonTrivialDefault;

		public static readonly Func<ISerializationContext, T> Factory;

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static T FromObject(object value)
		{
			if (value != null)
			{
				return (T)value;
			}
			return default(T);
		}

		static TypeHelper()
		{
			T @default = Default;
			NonTrivialDefault = ((@default != null) ? @default : ((T)TypeHelper.CreateNonTrivialDefault(typeof(T))));
			Factory = (ISerializationContext ctx) => TypeModel.CreateInstance<T>(ctx);
		}
	}
	internal interface IValueChecker<in T>
	{
		bool HasNonTrivialValue(T value);

		bool IsNull(T value);
	}
	internal sealed class ReferenceValueChecker : IValueChecker<object>
	{
		public static readonly ReferenceValueChecker Instance = new ReferenceValueChecker();

		private ReferenceValueChecker()
		{
		}

		bool IValueChecker<object>.HasNonTrivialValue(object value)
		{
			return value != null;
		}

		bool IValueChecker<object>.IsNull(object value)
		{
			return value == null;
		}
	}
	internal sealed class StructValueChecker<T> : IValueChecker<T?>, IValueChecker<T> where T : struct
	{
		public static readonly StructValueChecker<T> Instance = new StructValueChecker<T>();

		private StructValueChecker()
		{
		}

		bool IValueChecker<T?>.HasNonTrivialValue(T? value)
		{
			return value.HasValue;
		}

		bool IValueChecker<T?>.IsNull(T? value)
		{
			return !value.HasValue;
		}

		bool IValueChecker<T>.HasNonTrivialValue(T value)
		{
			return true;
		}

		bool IValueChecker<T>.IsNull(T value)
		{
			return false;
		}
	}
}